// public Funapi(TargetInfo Target) // <= 4.15
public Funapi(ReadOnlyTargetRules Target) : base(Target) // >= 4.16
{
PublicDefinitions.Add("WITH_FUNAPI=1");
PublicDefinitions.Add("FUNAPI_UE4=1");
PublicDefinitions.Add("FUNAPI_HAVE_ZLIB=1");
PublicDefinitions.Add("FUNAPI_HAVE_DELAYED_ACK=1");
PublicDefinitions.Add("FUNAPI_HAVE_TCP_TLS=1");
PublicDefinitions.Add("FUNAPI_HAVE_WEBSOCKET=1");
if (Target.Platform == UnrealTargetPlatform.PS4)
{
PublicDefinitions.Add("FUNAPI_HAVE_RPC=0");
}
else
{
PublicDefinitions.Add("FUNAPI_HAVE_RPC=1");
}
if (Target.Platform == UnrealTargetPlatform.Win32 ||
Target.Platform == UnrealTargetPlatform.Win64)
{
PublicDefinitions.Add("FUNAPI_PLATFORM_WINDOWS=1");
PublicDefinitions.Add("FUNAPI_UE4_PLATFORM_WINDOWS=1");
}
if (Target.Platform == UnrealTargetPlatform.Linux)
{
PublicDefinitions.Add("FUNAPI_HAVE_ZSTD=0");
PublicDefinitions.Add("FUNAPI_HAVE_SODIUM=0");
PublicDefinitions.Add("FUNAPI_HAVE_AES128=0");
}
else
{
PublicDefinitions.Add("FUNAPI_HAVE_ZSTD=1");
PublicDefinitions.Add("FUNAPI_HAVE_SODIUM=1");
if (Target.Platform == UnrealTargetPlatform.Android)
{
PublicDefinitions.Add("FUNAPI_HAVE_AES128=0");
}
else
{
PublicDefinitions.Add("FUNAPI_HAVE_AES128=1");
}
}
PublicIncludePaths.AddRange(
new string[] {
// NOTE(sungjin): Path를 문자열로 넘겨주지 않고
// Path.Combine(ModuleDirectory,"Path") 을 사용한다.
// 엔진이 플러그인의 Public, Private 폴더를 자동으로 추가해 주지만
// 잘못된 경로를 추가하는 현상이 있어
// Path.Combine 함수를 통해 명시적으로 표현하도록 하여 우회한다.
Path.Combine(ModuleDirectory, "Public"),
Path.Combine(ModuleDirectory, "Public/funapi"),
Path.Combine(ModuleDirectory, "Public/funapi/management"),
Path.Combine(ModuleDirectory, "Public/funapi/network"),
Path.Combine(ModuleDirectory, "Public/funapi/service"),
//... add public include paths required here...
}
);
PrivateIncludePaths.AddRange(
new string[] {
//ModuleDirectory = real dicractory path where Funapi.Build.cs
Path.Combine(ModuleDirectory, "Private"),
//... add other private include paths required here ...
}
);
PublicDependencyModuleNames.AddRange(
new string[]
{
"Core",
"Engine",
"zlib",
// ... add other public dependencies that you statically link with here ...
}
);
PrivateDependencyModuleNames.AddRange(
new string[]
{
// ... add private dependencies that you statically link with here ...
}
);
DynamicallyLoadedModuleNames.AddRange(
new string[]
{
// ... add any modules that your module loads dynamically here ...
}
);
// definitions
PublicDefinitions.Add("RAPIDJSON_HAS_STDSTRING=0");
PublicDefinitions.Add("RAPIDJSON_HAS_CXX11_RVALUE_REFS=0");
// definitions for zlib
PublicDefinitions.Add("_LARGEFILE64_SOURCE=0");
PublicDefinitions.Add("_FILE_OFFSET_BITS=0");
// Third party library
var ThirdPartyPath = Path.GetFullPath(Path.Combine(ModuleDirectory, "..", "..", "ThirdParty/"));
// include path
PublicIncludePaths.Add(Path.Combine(ThirdPartyPath, "include"));
// library
var LibPath = ThirdPartyPath;
if (Target.Platform == UnrealTargetPlatform.Mac)
{
PublicIncludePaths.Add(Path.Combine(ThirdPartyPath, "include", "Mac"));
LibPath += "lib/Mac";
PublicAdditionalLibraries.Add(Path.Combine(LibPath, "libcurl.a"));
PublicAdditionalLibraries.Add(Path.Combine(LibPath, "libcrypto.a"));
PublicAdditionalLibraries.Add(Path.Combine(LibPath, "libssl.a"));
PublicAdditionalLibraries.Add(Path.Combine(LibPath, "libz.a"));
PublicAdditionalLibraries.Add(Path.Combine(LibPath, "libsodium.a"));
PublicAdditionalLibraries.Add(Path.Combine(LibPath, "libwebsockets.a"));
PublicAdditionalLibraries.Add(Path.Combine(LibPath, "libzstd.a"));
}
else if (Target.Platform == UnrealTargetPlatform.Win32)
{
PublicIncludePaths.Add(Path.Combine(ThirdPartyPath, "include", "Windows", "x86"));
LibPath += "lib/Windows/x86";
PublicLibraryPaths.Add(LibPath);
PublicDefinitions.Add("CURL_STATICLIB=1");
PublicAdditionalLibraries.Add(Path.Combine(LibPath, "libcurl_a.lib"));
PublicAdditionalLibraries.Add(Path.Combine(LibPath, "libeay32.lib"));
PublicAdditionalLibraries.Add(Path.Combine(LibPath, "libsodium.lib"));
PublicAdditionalLibraries.Add(Path.Combine(LibPath, "websockets_static.lib"));
PublicAdditionalLibraries.Add(Path.Combine(LibPath, "libzstd_static.lib"));
}
else if (Target.Platform == UnrealTargetPlatform.Win64)
{
PublicIncludePaths.Add(Path.Combine(ThirdPartyPath, "include", "Windows", "x64"));
LibPath += "lib/Windows/x64";
PublicLibraryPaths.Add(LibPath);
PublicDefinitions.Add("CURL_STATICLIB=1");
PublicAdditionalLibraries.Add(Path.Combine(LibPath, "libcurl_a.lib"));
PublicAdditionalLibraries.Add(Path.Combine(LibPath, "libsodium.lib"));
PublicAdditionalLibraries.Add(Path.Combine(LibPath, "websockets_static.lib"));
PublicAdditionalLibraries.Add(Path.Combine(LibPath, "libzstd_static.lib"));
}
else if (Target.Platform == UnrealTargetPlatform.Android)
{
PublicDefinitions.Add("FUNAPI_UE4_PLATFORM_ANDROID=1");
// toolchain will filter properly
PublicIncludePaths.Add(LibPath + "include/Android/ARMv7");
PublicLibraryPaths.Add(LibPath + "lib/Android/ARMv7");
PublicIncludePaths.Add(LibPath + "include/Android/ARM64");
PublicLibraryPaths.Add(LibPath + "lib/Android/ARM64");
PublicAdditionalLibraries.Add("sodium");
PublicAdditionalLibraries.Add("curl");
PublicAdditionalLibraries.Add("ssl");
PublicAdditionalLibraries.Add("crypto");
PublicAdditionalLibraries.Add("websockets");
PublicAdditionalLibraries.Add("zstd");
}
else if (Target.Platform == UnrealTargetPlatform.IOS)
{
PublicDefinitions.Add("WITH_HOT_RELOAD=0");
PublicIncludePaths.Add(Path.Combine(ThirdPartyPath, "include", "iOS"));
LibPath += "lib/iOS";
PublicAdditionalLibraries.Add(Path.Combine(LibPath, "libcurl.a"));
PublicAdditionalLibraries.Add(Path.Combine(LibPath, "libcrypto.a"));
PublicAdditionalLibraries.Add(Path.Combine(LibPath, "libssl.a"));
PublicAdditionalLibraries.Add(Path.Combine(LibPath, "libsodium.a"));
PublicAdditionalLibraries.Add(Path.Combine(LibPath, "libwebsockets.a"));
PublicAdditionalLibraries.Add(Path.Combine(LibPath, "libzstd.a"));
}
else if (Target.Platform == UnrealTargetPlatform.PS4)
{
PublicDefinitions.Add("FUNAPI_UE4_PLATFORM_PS4=1");
PublicIncludePaths.Add(Path.Combine(ThirdPartyPath, "include", "PS4"));
LibPath += "lib/PS4";
PublicAdditionalLibraries.Add(Path.Combine(LibPath, "libsodium.a"));
PublicAdditionalLibraries.Add(Path.Combine(LibPath, "libzstd_static.a"));
PublicDependencyModuleNames.AddRange(new string[] { "WebSockets" });
AddEngineThirdPartyPrivateStaticDependencies(Target, "OpenSSL", "libWebSockets");
}
else if (Target.Platform == UnrealTargetPlatform.Linux)
{
PublicDefinitions.Add("FUNAPI_UE4_PLATFORM_LINUX=1");
AddEngineThirdPartyPrivateStaticDependencies(Target, "OpenSSL", "libWebSockets", "libcurl");
}
}
public CGAL(ReadOnlyTargetRules Target) : base(Target)
{
bEnableUndefinedIdentifierWarnings = false;
PublicDefinitions.Add("WIN32");
PublicDefinitions.Add("_WINDOWS");
PublicDefinitions.Add("_CRT_SECURE_NO_DEPRECATE");
PublicDefinitions.Add("_SCL_SECURE_NO_DEPRECATE");
PublicDefinitions.Add("_CRT_SECURE_NO_WARNINGS");
PublicDefinitions.Add("_SCL_SECURE_NO_WARNINGS");
PublicDefinitions.Add("CGAL_USE_MPFR");
PublicDefinitions.Add("CGAL_USE_GMP");
// Startard Module Dependencies
PublicDependencyModuleNames.AddRange(new string[] { "Core" });
PrivateDependencyModuleNames.AddRange(new string[] { "CoreUObject", "Engine", "Slate", "SlateCore" });
// Start CGAL linking here!
bool isLibrarySupported = false;
// Create CGAL Path
string CGALPath = Path.Combine(ThirdPartyPath, "CGAL");
// Get Library Path
string LibPath = "";
bool isdebug = Target.Configuration == UnrealTargetConfiguration.Debug && Target.bDebugBuildsActuallyUseDebugCRT;
if (Target.Platform == UnrealTargetPlatform.Win64)
{
LibPath = Path.Combine(CGALPath, "libraries", "Win64");
isLibrarySupported = true;
}
else
{
string Err = string.Format("{0} dedicated server is made to depend on {1}. We want to avoid this, please correct module dependencies.", Target.Platform.ToString(), this.ToString()); System.Console.WriteLine(Err);
}
if (isLibrarySupported)
{
//Add Include path
PublicIncludePaths.AddRange(new string[] { Path.Combine(CGALPath, "includes") });
PublicIncludePaths.AddRange(new string[] { Path.Combine(CGALPath, "includes", "GMP") });//Dependencie
// Add Library Path
PublicLibraryPaths.Add(LibPath);
// Add Dependencies
if (!isdebug)
{
//Add Static Libraries
PublicAdditionalLibraries.Add(Path.Combine("libgmp-10.lib"));
PublicAdditionalLibraries.Add(Path.Combine("libmpfr-4.lib"));
PublicAdditionalLibraries.Add(Path.Combine("libCGAL-vc140-mt-4.9.lib"));
PublicAdditionalLibraries.Add(Path.Combine("libCGAL_Core-vc140-mt-4.9.lib"));
}
else
{
//Add Static Libraries (Debug Version)
PublicAdditionalLibraries.Add(Path.Combine("libgmp-10.lib"));
PublicAdditionalLibraries.Add(Path.Combine("libmpfr-4.lib"));
PublicAdditionalLibraries.Add(Path.Combine("libCGAL-vc140-mt-gd-4.9.lib"));
PublicAdditionalLibraries.Add(Path.Combine("libCGAL_Core-vc140-mt-gd-4.9.lib"));
}
}
PublicDefinitions.Add(string.Format("WITH_CGAL_BINDING={0}", isLibrarySupported ? 1 : 0));
}
public MeshModelingToolsEditorOnly(ReadOnlyTargetRules Target) : base(Target)
{
PCHUsage = ModuleRules.PCHUsageMode.UseExplicitOrSharedPCHs;
PublicIncludePaths.AddRange(
new string[] {
// ... add public include paths required here ...
}
);
PrivateIncludePaths.AddRange(
new string[] {
// ... add other private include paths required here ...
}
);
PublicDependencyModuleNames.AddRange(
new string[]
{
"Core",
"InteractiveToolsFramework",
"MeshDescription",
"StaticMeshDescription",
"GeometricObjects",
"DynamicMesh",
"MeshConversion",
"MeshModelingTools",
"ModelingComponents",
"ModelingOperators",
"ModelingOperatorsEditorOnly",
"ProxyLODMeshReduction", // currently required to be public due to IVoxelBasedCSG API
// ... add other public dependencies that you statically link with here ...
"HairStrandsCore" // required for Hair toolset
}
);
PrivateDependencyModuleNames.AddRange(
new string[]
{
"CoreUObject",
"Engine",
"RenderCore",
"RHI",
"InputCore",
"MeshUtilities", // tangents calculation
"UnrealEd",
"MeshBuilder",
"MeshUtilitiesCommon",
"MeshReductionInterface", // for UE4 standard simplification
"ProxyLODMeshReduction", // for mesh merging voxel-based csg
//"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 UnrealEd(TargetInfo Target)
{
SharedPCHHeaderFile = "Editor/UnrealEd/Public/UnrealEd.h";
PrivateIncludePaths.AddRange(
new string[]
{
"Editor/UnrealEd/Private",
"Editor/UnrealEd/Private/Settings",
"Editor/PackagesDialog/Public",
"Developer/DerivedDataCache/Public",
"Developer/TargetPlatform/Public",
}
);
PrivateIncludePathModuleNames.AddRange(
new string[]
{
"AssetRegistry",
"AssetTools",
"BehaviorTreeEditor",
"ClassViewer",
"ContentBrowser",
"CrashTracker",
"DerivedDataCache",
"DesktopPlatform",
"EnvironmentQueryEditor",
"GameProjectGeneration",
"ProjectTargetPlatformEditor",
"ImageWrapper",
"MainFrame",
"MaterialEditor",
"MergeActors",
"MeshUtilities",
"Messaging",
"MovieSceneCapture",
"NiagaraEditor",
"PlacementMode",
"Settings",
"SettingsEditor",
"SoundClassEditor",
"ViewportSnapping",
"SourceCodeAccess",
"ReferenceViewer",
"IntroTutorials",
"SuperSearch",
"OutputLog",
"Landscape",
"Niagara",
"SizeMap",
"LocalizationService",
"HierarchicalLODUtilities",
"MessagingRpc",
"PortalRpc",
"PortalServices",
"BlueprintNativeCodeGen",
}
);
PublicDependencyModuleNames.AddRange(
new string[]
{
"BspMode",
"Core",
"CoreUObject",
"DirectoryWatcher",
"Documentation",
"Engine",
"Json",
"Projects",
"SandboxFile",
"Slate",
"SlateCore",
"EditorStyle",
"SourceControl",
"UnrealEdMessages",
"AIModule",
"GameplayDebugger",
"BlueprintGraph",
"Http",
"UnrealAudio",
"Niagara",
"VectorVM",
"FunctionalTesting"
}
);
PrivateDependencyModuleNames.AddRange(
new string[]
{
"LevelSequence",
"AnimGraph",
"AppFramework",
"BlueprintGraph",
"OnlineSubsystem",
"OnlineSubsystemUtils",
"OnlineBlueprintSupport",
"DesktopPlatform",
"EditorStyle",
"EngineSettings",
"InputCore",
"InputBindingEditor",
"Internationalization",
"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",
"MaterialUtilities",
"LocalizationService",
"AddContentDialog",
"GameProjectGeneration",
"HierarchicalLODUtilities",
"AnalyticsET",
"PluginWarden"
}
);
DynamicallyLoadedModuleNames.AddRange(
new string[]
{
"CrashTracker",
"FontEditor",
"StaticMeshEditor",
"TextureEditor",
"Cascade",
"UMGEditor",
"Matinee",
"AssetRegistry",
"AssetTools",
"ClassViewer",
"CollectionManager",
"ContentBrowser",
"CurveTableEditor",
"DataTableEditor",
"DestructibleMeshEditor",
"EditorSettingsViewer",
"LandscapeEditor",
"KismetCompiler",
"DetailCustomizations",
"ComponentVisualizers",
"MainFrame",
"LevelEditor",
"PackagesDialog",
"Persona",
"PhAT",
"ProjectLauncher",
"DeviceManager",
"SettingsEditor",
"SessionFrontend",
"Sequencer",
"GeometryMode",
"TextureAlignMode",
"FoliageEdit",
"PackageDependencyInfo",
"ImageWrapper",
"Blutility",
"IntroTutorials",
"SuperSearch",
"WorkspaceMenuStructure",
"PlacementMode",
"NiagaraEditor",
"MeshUtilities",
"MergeActors",
"ProjectSettingsViewer",
"ProjectTargetPlatformEditor",
"PListEditor",
"BehaviorTreeEditor",
"EnvironmentQueryEditor",
"ViewportSnapping",
"UserFeedback",
"GameplayTagsEditor",
"GameplayTasksEditor",
"GameplayAbilitiesEditor",
"UndoHistory",
"SourceCodeAccess",
"ReferenceViewer",
"EditorLiveStreaming",
"HotReload",
"IOSPlatformEditor",
"HTML5PlatformEditor",
"SizeMap",
"PortalProxies",
"PortalServices",
"GeometryCacheEd",
"BlueprintNativeCodeGen",
}
);
if (Target.Platform == UnrealTargetPlatform.Win64 || Target.Platform == UnrealTargetPlatform.Win32 || Target.Platform == UnrealTargetPlatform.Mac)
{
DynamicallyLoadedModuleNames.Add("AndroidPlatformEditor");
}
if (Target.Type == TargetRules.TargetType.Editor)
{
DynamicallyLoadedModuleNames.Add("SequenceRecorder");
PrivateIncludePathModuleNames.Add("SequenceRecorder");
}
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",
"AddContentDialog",
"MeshUtilities"
}
);
if ((Target.Platform == UnrealTargetPlatform.Win64) ||
(Target.Platform == UnrealTargetPlatform.Win32))
{
PublicDependencyModuleNames.Add("XAudio2");
PublicDependencyModuleNames.Add("UnrealAudioXAudio2");
AddEngineThirdPartyPrivateStaticDependencies(Target,
"UEOgg",
"Vorbis",
"VorbisFile",
"DX11Audio"
);
}
if (Target.Platform == UnrealTargetPlatform.Mac)
{
PublicDependencyModuleNames.Add("UnrealAudioCoreAudio");
}
if (Target.Platform == UnrealTargetPlatform.HTML5)
{
PublicDependencyModuleNames.Add("ALAudio");
}
AddEngineThirdPartyPrivateStaticDependencies(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 GPGPUPlugin(ReadOnlyTargetRules Target) : base(Target)
{
bEnableUndefinedIdentifierWarnings = false;
PCHUsage = ModuleRules.PCHUsageMode.UseExplicitOrSharedPCHs;
PublicIncludePaths.AddRange(
new string[] {
Path.Combine(ThirdPartyDirectory, "Include")
// ... add public include paths required here ...
}
);
PrivateIncludePaths.AddRange(
new string[] {
// ... 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[]
{
"CoreUObject",
"Engine",
"Slate",
"SlateCore",
"AssetTools",
"ClassViewer",
"UnrealEd"
// ... add private dependencies that you statically link with here ...
}
);
DynamicallyLoadedModuleNames.AddRange(
new string[]
{
// ... add any modules that your module loads dynamically here ...
}
);
string PlatformString = (Target.Platform == UnrealTargetPlatform.Win64) ? "Win64" : "Win32";
string OpenCLLibrariesPath = Path.Combine(ThirdPartyDirectory, "Lib");
string NvidiaLibrariesPath = Path.Combine(OpenCLLibrariesPath, "NVIDIA", PlatformString);
string IntelLibrariesPath = Path.Combine(OpenCLLibrariesPath, "Intel", PlatformString);
string AmdLibrariesPath = Path.Combine(OpenCLLibrariesPath, "AMD", PlatformString);
string BoostLibrariesPath = Path.Combine(OpenCLLibrariesPath, "Boost");
if (Target.Platform == UnrealTargetPlatform.Win64)
{
string[] BoostLibs = Directory.GetFiles(BoostLibrariesPath, "*x64*.lib", SearchOption.AllDirectories);
foreach (string boostLib in BoostLibs)
{
PublicAdditionalLibraries.Add(boostLib);
}
}
else if (Target.Platform == UnrealTargetPlatform.Win32)
{
string[] BoostLibs = Directory.GetFiles(BoostLibrariesPath, "*x32*.lib", SearchOption.AllDirectories);
foreach (string boostLib in BoostLibs)
{
PublicAdditionalLibraries.Add(boostLib);
}
}
if (Target.Platform == UnrealTargetPlatform.Win64 || Target.Platform == UnrealTargetPlatform.Win32)
{
PublicAdditionalLibraries.Add(Path.Combine(NvidiaLibrariesPath, "OpenCL.lib"));
PublicAdditionalLibraries.Add(Path.Combine(IntelLibrariesPath, "OpenCL.lib"));
PublicAdditionalLibraries.Add(Path.Combine(AmdLibrariesPath, "OpenCL.lib"));
PublicAdditionalLibraries.Add(Path.Combine(NvidiaLibrariesPath, "cuda.lib"));
PublicAdditionalLibraries.Add(Path.Combine(NvidiaLibrariesPath, "cudadevrt.lib"));
PublicAdditionalLibraries.Add(Path.Combine(NvidiaLibrariesPath, "cudart.lib"));
PublicAdditionalLibraries.Add(Path.Combine(NvidiaLibrariesPath, "cudart_static.lib"));
PublicAdditionalLibraries.Add(Path.Combine(NvidiaLibrariesPath, "nvcuvid.lib"));
}
else if (Target.Platform == UnrealTargetPlatform.Mac)
{
PublicAdditionalFrameworks.Add(new UEBuildFramework("OpenCL"));
}
if (Target.Platform == UnrealTargetPlatform.Win64)
{
PublicAdditionalLibraries.Add(Path.Combine(NvidiaLibrariesPath, "nvrtc.lib"));
}
}
public celestialdemo(TargetInfo Target)
{
PublicDependencyModuleNames.AddRange(new string[] { "Core", "CoreUObject", "Engine", "InputCore", "RHI", "SkyboxShader", "ShaderCopyHelper" });
PrivateDependencyModuleNames.AddRange(new string[] { });
}
public Voxel(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"));
// For raytracing
PrivateIncludePaths.Add(EngineDirectory + "/Shaders/Shared");
// For HLSL translator
PrivateIncludePaths.Add(EngineDirectory + "/Source/Runtime/Engine/Private");
PublicDependencyModuleNames.AddRange(
new string[]
{
"Core",
"CoreUObject",
"Engine",
"Networking",
"Sockets",
"RHI",
#if UE_4_23_OR_LATER
"PhysicsCore",
#endif
"RenderCore",
"Landscape",
"PhysX",
#if UE_4_26_OR_LATER
"DeveloperSettings",
"TraceLog",
#endif
}
);
PrivateDependencyModuleNames.AddRange(
new string[]
{
"nvTessLib",
"HTTP",
"Projects",
"Slate",
"SlateCore",
//"VHACD", // Not used, too slow
}
);
SetupModulePhysicsSupport(Target);
if (Target.Platform == UnrealTargetPlatform.Win64)
{
PrivateDependencyModuleNames.Add("ForsythTriOptimizer");
}
PrivateDependencyModuleNames.Add("zlib");
if (Target.Configuration == UnrealTargetConfiguration.DebugGame ||
Target.Configuration == UnrealTargetConfiguration.Debug)
{
PublicDefinitions.Add("VOXEL_DEBUG=1");
}
PublicDefinitions.Add("VOXEL_PLUGIN_NAME=TEXT(\"VoxelFree\")");
}
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("D3D11RHI");
DynamicallyLoadedModuleNames.Add("XAudio2");
}
else if (Target.Platform == UnrealTargetPlatform.Mac)
{
DynamicallyLoadedModuleNames.Add("CoreAudio");
}
else if (Target.Platform == UnrealTargetPlatform.Linux)
{
DynamicallyLoadedModuleNames.Add("ALAudio");
}
PrivateIncludePathModuleNames.AddRange(
new string[] {
"SlateRHIRenderer",
}
);
DynamicallyLoadedModuleNames.AddRange(
new string[] {
"SlateRHIRenderer",
"HeadMountedDisplay"
}
);
}
// 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" });
}
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[] {
"AutomationController",
"AutomationWorker",
"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)
{
PrivateDependencyModuleNames.Add("OpenGLDrv");
DynamicallyLoadedModuleNames.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("HTML5Audio");
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;
}
}
public TimeAttackRacer(TargetInfo Target)
{
PublicDependencyModuleNames.AddRange(new string[] { "Core", "CoreUObject", "Engine", "InputCore", "PhysXVehicles", "HeadMountedDisplay", "UMG" });
PrivateDependencyModuleNames.AddRange(new string[] { "Slate", "SlateCore" });
}
public AlphaOmega(TargetInfo Target)
{
PublicDependencyModuleNames.AddRange(new string[] { "Core", "CoreUObject", "Engine", "InputCore", "UMG", "ProceduralMeshComponent" });
PrivateDependencyModuleNames.AddRange(new string[] { "Slate", "SlateCore" });
}
public glTFForUE4Ed(TargetInfo Target)
{
PublicIncludePaths.AddRange(
new string[] {
"glTFForUE4Ed/Public"
// ... add public include paths required here ...
}
);
PrivateIncludePaths.AddRange(
new string[] {
"glTFForUE4Ed/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[]
{
"CoreUObject",
"Engine",
"Slate",
"SlateCore",
"InputCore",
"RenderCore",
"UnrealEd",
"MainFrame",
"Documentation",
"PropertyEditor",
"EditorStyle",
"RawMesh",
"glTFForUE4",
// ... add private dependencies that you statically link with here ...
}
);
DynamicallyLoadedModuleNames.AddRange(
new string[]
{
// ... add any modules that your module loads dynamically here ...
}
);
// libgltf
string LibName = "libgltf";
string LibPathRoot = System.IO.Path.Combine(ModuleDirectory, "..", "..", "Extras", LibName);
string LibPathInclude = System.IO.Path.Combine(LibPathRoot, "include");
PublicIncludePaths.Add(LibPathInclude);
string LibPathBinary = System.IO.Path.Combine(LibPathRoot, "bin");
if (Target.Platform == UnrealTargetPlatform.Win64)
{
LibPathBinary = System.IO.Path.Combine(LibPathBinary, "win64");
if (Target.Configuration == UnrealTargetConfiguration.Debug ||
Target.Configuration == UnrealTargetConfiguration.DebugGame)
{
LibPathBinary = System.IO.Path.Combine(LibPathBinary, "Debug");
LibName = LibName + "d";
}
else
{
LibPathBinary = System.IO.Path.Combine(LibPathBinary, "Release");
}
LibName = LibName + ".lib";
}
else if (Target.Platform == UnrealTargetPlatform.Mac)
{
LibPathBinary = System.IO.Path.Combine(LibPathBinary, "macos");
if (Target.Configuration == UnrealTargetConfiguration.Debug ||
Target.Configuration == UnrealTargetConfiguration.DebugGame)
{
LibPathBinary = System.IO.Path.Combine(LibPathBinary, "Debug");
LibName = LibName + "d";
}
else
{
LibPathBinary = System.IO.Path.Combine(LibPathBinary, "Release");
}
LibName = LibPathBinary + "/" + LibName + ".a";
}
PublicLibraryPaths.Add(LibPathBinary);
PublicAdditionalLibraries.Add(LibName);
}
public Fuse(TargetInfo Target)
{
PublicIncludePaths.AddRange(
new string[] {
// ... add public include paths required here ...
}
);
PrivateIncludePaths.AddRange(
new string[] {
"Developer/Fuse/Private",
// ... add other private include paths required here ...
}
);
PublicDependencyModuleNames.AddRange(
new string[]
{
"Core",
"CoreUObject",
"Engine",
"OnlineSubsystem"
// ... add other public dependencies that you statically link with here ...
}
);
PrivateDependencyModuleNames.AddRange(
new string[]
{
// ... add private dependencies that you statically link with here ...
}
);
DynamicallyLoadedModuleNames.AddRange(
new string[]
{
// ... add any modules that your module loads dynamically here ...
}
);
PrivateIncludePathModuleNames.AddRange(
new string[]
{
"Settings"
}
);
if (Target.Platform == UnrealTargetPlatform.IOS)
{
// required frameworks
PublicFrameworks.AddRange(
new string[]
{
"Accelerate",
"AdSupport",
"AudioToolbox",
"AVFoundation",
"CoreGraphics",
"CoreLocation",
"CoreMedia",
"CoreTelephony",
"EventKit",
"EventKitUI",
"Foundation",
"GameKit",
"MediaPlayer",
"MessageUI",
"MobileCoreServices",
"QuartzCore",
"Social",
"StoreKit",
"SystemConfiguration",
"Twitter",
"UIKit"
}
);
// required libs
PublicAdditionalLibraries.Add("sqlite3");
PublicAdditionalLibraries.Add("xml2");
PublicAdditionalLibraries.Add("z");
// include Fuse SDK
var CodeDir = Path.Combine(ModulePath, "..", "..", "lib", "FuseSDKiOS", "Code");
PrivateIncludePaths.Add(CodeDir);
PublicAdditionalLibraries.Add(Path.Combine(CodeDir, "libFuseSDK.a"));
// collect settings
ConfigCacheIni Ini = new ConfigCacheIni(UnrealTargetPlatform.IOS, "Engine", UnrealBuildTool.GetUProjectPath());
bool bIncludeAdColony = false;
bool bIncludeAppLovin = false;
bool bIncludeHyprMX = false;
bool bIncludeAdMob = false;
bool bIncludeChartboost = false;
bool bIncludeFacebook = false;
bool bIncludeiAd = false;
bool bIncludeMillennial = false;
string SettingsPath = "/Script/Fuse.FuseSettings";
Ini.GetBool(SettingsPath, "bIncludeAdColony", out bIncludeAdColony);
Ini.GetBool(SettingsPath, "bIncludeAppLovin", out bIncludeAppLovin);
Ini.GetBool(SettingsPath, "bIncludeHyprMX", out bIncludeHyprMX);
Ini.GetBool(SettingsPath, "bIncludeAdMob", out bIncludeAdMob);
Ini.GetBool(SettingsPath, "bIncludeChartboost", out bIncludeChartboost);
Ini.GetBool(SettingsPath, "bIncludeFacebook", out bIncludeFacebook);
Ini.GetBool(SettingsPath, "bIncludeiAd", out bIncludeiAd);
Ini.GetBool(SettingsPath, "bIncludeMillennial", out bIncludeMillennial);
// include optional adapters
if (bIncludeAdColony)
{
PublicAdditionalLibraries.Add(Path.Combine(CodeDir, "libFuseAdapterAdcolony.a"));
}
if (bIncludeAppLovin)
{
PublicAdditionalLibraries.Add(Path.Combine(CodeDir, "libFuseAdapterAppLovin.a"));
}
if (bIncludeHyprMX)
{
PublicAdditionalLibraries.Add(Path.Combine(CodeDir, "libFuseAdapterHyprMX.a"));
}
var FuseExtrasDir = Path.Combine(ModulePath, "..", "..", "lib", "FuseSDKiOS", "Extras");
var ExtrasiOSDir = "../../lib/Extras/iOS";
if (bIncludeAdMob)
{
PublicAdditionalLibraries.Add(Path.Combine(FuseExtrasDir, "AdMob", "libFuseAdapterAdMob.a"));
PublicAdditionalFrameworks.Add(
new UEBuildFramework(
"GoogleMobileAds",
ExtrasiOSDir + "/AdMob/GoogleMobileAds.embeddedframework.zip"
)
);
}
if (bIncludeChartboost)
{
PublicAdditionalLibraries.Add(Path.Combine(FuseExtrasDir, "ChartBoost", "libFuseAdapterChartBoost.a"));
PublicAdditionalFrameworks.Add(
new UEBuildFramework(
"Chartboost",
ExtrasiOSDir + "/Chartboost/Chartboost.embeddedframework.zip"
)
);
}
if (bIncludeFacebook)
{
PublicAdditionalLibraries.Add(Path.Combine(FuseExtrasDir, "Facebook", "libFuseAdapterFacebook.a"));
PublicAdditionalFrameworks.Add(
new UEBuildFramework(
"FBAudienceNetwork",
ExtrasiOSDir + "/Facebook/FBAudienceNetwork.embeddedframework.zip"
)
);
}
if (bIncludeiAd)
{
PublicAdditionalLibraries.Add(Path.Combine(FuseExtrasDir, "iAd", "libFuseAdapteriAd.a"));
}
if (bIncludeMillennial)
{
PublicAdditionalLibraries.Add(Path.Combine(FuseExtrasDir, "Millennial", "libFuseAdapterMillennial.a"));
PublicAdditionalFrameworks.Add(
new UEBuildFramework(
"MillennialMedia",
ExtrasiOSDir + "/Millennial/MillennialMedia.embeddedframework.zip"
)
);
PublicAdditionalLibraries.Add(Path.Combine(FuseExtrasDir, "AdMob", "libFuseAdapterAdMob.a"));
PublicAdditionalFrameworks.Add(
new UEBuildFramework(
"SpeechKit",
ExtrasiOSDir + "/Millennial/SpeechKit.embeddedframework.zip"
)
);
}
}
}
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 modio(ReadOnlyTargetRules Target) : base(Target)
{
PublicDefinitions.Add("JSON_NOEXCEPTION");
PCHUsage = PCHUsageMode.UseExplicitOrSharedPCHs;
// For beeing able to declare something public inside of the module, but private to outsiders
PrivateDefinitions.Add("MODIO_PACKAGE=1");
PrivateDependencyModuleNames.AddRange(new string[] { });
#if UE_4_24_OR_LATER
DefaultBuildSettings = BuildSettingsVersion.V2;
#endif
LoadModio(Target);
// @todo: Can we disable exceptions again?
bEnableExceptions = true;
// Made sure to disable unity builds, as exclusion of some files causes the project to explode
// this was we atleast get deterministic builds even if they are slower
MinSourceFilesForUnityBuildOverride = 256;
PublicIncludePaths.AddRange(
new string[] {
//"modio/Public"
/*,
* "Runtime/Core/Public/Modules/",
* "Editor/UnrealEd/Classes/Factories",
* "Editor/UnrealEd/Classes",
* "C:/Users/antar/Documents/Unreal Projects/ModioContainer21/Plugins/modio/Intermediate/Build/Win64/UE4Editor/Inc/modio",
* "C:/Program Files/Epic Games/UE_4.21/Engine/Intermediate/Build/Win64/UE4Editor/Inc/UnrealEd"
*/
// ... add public include paths required here ...
}
);
PrivateIncludePaths.AddRange(
new string[] {
//"modio/Private",
// ... add other private include paths required here ...
}
);
PublicDependencyModuleNames.AddRange(
new string[]
{
"Core",
"CoreUObject",
"Engine",
"InputCore",
"Projects",
"Int64"
// ... add other public dependencies that you statically link with here ...
}
);
PrivateDependencyModuleNames.AddRange(
new string[]
{
// ... add private dependencies that you statically link with here ...
}
);
DynamicallyLoadedModuleNames.AddRange(
new string[]
{
// ... add any modules that your module loads dynamically here ...
}
);
}
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");
}
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");
}
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 DlgSystem(ReadOnlyTargetRules Target) : base(Target)
{
// Enable IWYU
// https://docs.unrealengine.com/latest/INT/Programming/UnrealBuildSystem/IWYUReferenceGuide/index.html
// https://docs.unrealengine.com/latest/INT/Programming/UnrealBuildSystem/Configuration/
PCHUsage = PCHUsageMode.UseExplicitOrSharedPCHs;
bEnforceIWYU = true;
//MinFilesUsingPrecompiledHeaderOverride = 1;
//bFasterWithoutUnity = true;
//PrivatePCHHeaderFile = "Private/DlgSystemPrivatePCH.h";
PublicIncludePaths.AddRange(
new string[] {
Path.Combine(ModuleDirectory, "Public")
// ... add public include paths required here ...
});
PrivateIncludePaths.AddRange(
new string[] {
Path.Combine(ModuleDirectory, "Private")
// ... add other private include paths required here ...
});
PublicDependencyModuleNames.AddRange(
new string[] {
"Core",
"Json",
"JsonUtilities"
// ... add other public dependencies that you statically link with here ...
});
PrivateDependencyModuleNames.AddRange(
new string[] {
"CoreUObject",
"Engine",
"Projects", // IPluginManager
// UI
"SlateCore",
"Slate",
"InputCore"
// ... add private dependencies that you statically link with here ...
});
// We need this dependency when the DlgSystem works in the editor mode/built with editor
if (Target.bBuildEditor)
{
PrivateDependencyModuleNames.Add("UnrealEd");
// Accessing the menu
PrivateDependencyModuleNames.Add("WorkspaceMenuStructure");
}
// Add GameplayDebugger functionality if not 'Shipping' or 'Test' Target.
if (Target.bBuildDeveloperTools ||
(Target.Configuration != UnrealTargetConfiguration.Shipping && Target.Configuration != UnrealTargetConfiguration.Test))
{
PrivateDependencyModuleNames.Add("GameplayDebugger");
PublicDefinitions.Add("WITH_GAMEPLAY_DEBUGGER=1");
}
else
{
PublicDefinitions.Add("WITH_GAMEPLAY_DEBUGGER=0");
}
DynamicallyLoadedModuleNames.AddRange(
new string[] {
// ... add any modules that your module loads dynamically here ...
});
}
public HoudiniEngineEditor(TargetInfo Target)
{
bool bIsRelease = true;
string HFSPath = "";
string HoudiniVersion = "15.0.389";
// Check if we are compiling on unsupported platforms.
if (Target.Platform != UnrealTargetPlatform.Win64 &&
Target.Platform != UnrealTargetPlatform.Mac)
{
string Err = string.Format("Houdini Engine Runtime: Compiling on unsupported platform.");
System.Console.WriteLine(Err);
throw new BuildException(Err);
}
if (bIsRelease)
{
if (Target.Platform == UnrealTargetPlatform.Win64)
{
// We first check if Houdini Engine is installed.
string HPath = "C:/Program Files/Side Effects Software/Houdini Engine " + HoudiniVersion;
if (!Directory.Exists(HPath))
{
// If Houdini Engine is not installed, we check for Houdini installation.
HPath = "C:/Program Files/Side Effects Software/Houdini " + HoudiniVersion;
if (!Directory.Exists(HPath))
{
if (!Directory.Exists(HFSPath))
{
string Err = string.Format("Houdini Engine : Please install Houdini or Houdini Engine {0}", HoudiniVersion);
System.Console.WriteLine(Err);
}
}
else
{
HFSPath = HPath;
}
}
else
{
HFSPath = HPath;
}
}
else if (Target.Platform == UnrealTargetPlatform.Mac)
{
string HPath = "/Library/Frameworks/Houdini.framework/Versions/" + HoudiniVersion + "/Resources";
if (!Directory.Exists(HPath))
{
if (!Directory.Exists(HFSPath))
{
string Err = string.Format("Houdini Engine : Please install Houdini {0}", HoudiniVersion);
System.Console.WriteLine(Err);
}
}
else
{
HFSPath = HPath;
}
}
}
string HAPIIncludePath = "";
if (HFSPath != "")
{
HAPIIncludePath = HFSPath + "/toolkit/include/HAPI";
if (Target.Platform == UnrealTargetPlatform.Win64)
{
Definitions.Add("HOUDINI_ENGINE_HFS_PATH_DEFINE=" + HFSPath);
}
}
if (HAPIIncludePath != "")
{
PublicIncludePaths.Add(HAPIIncludePath);
}
PublicIncludePaths.AddRange(
new string[] {
"HoudiniEngineRuntime/Public/HAPI",
"HoudiniEngineRuntime/Public",
"HoudiniEngineEditor/Public"
}
);
PrivateIncludePaths.AddRange(
new string[] {
"HoudiniEngineEditor/Private",
"HoudiniEngineRuntime/Private"
}
);
// Add common dependencies.
PublicDependencyModuleNames.AddRange(
new string[]
{
"Core",
"CoreUObject",
"Engine",
"RenderCore",
"ShaderCore",
"InputCore",
"RHI",
"AssetTools",
"UnrealEd",
"Slate",
"SlateCore",
"Projects",
"PropertyEditor",
"ContentBrowser",
"RawMesh",
"TargetPlatform",
"LevelEditor",
"MainFrame",
"EditorStyle",
"EditorWidgets",
"AppFramework",
"HoudiniEngineRuntime"
}
);
PrivateDependencyModuleNames.AddRange(
new string[]
{
// ... add private dependencies that you statically link with here ...
}
);
DynamicallyLoadedModuleNames.AddRange(
new string[]
{
// ... add any modules that your module loads dynamically here ...
}
);
}
public VaRestEditorPlugin(ReadOnlyTargetRules Target) : base(Target)
{
PCHUsage = PCHUsageMode.UseExplicitOrSharedPCHs;
PublicIncludePaths.AddRange(
new string[] {
"VaRestPlugin",
"VaRestPlugin/Public"
// ... add public include paths required here ...
});
PrivateIncludePaths.AddRange(
new string[] {
"VaRestEditorPlugin/Private",
// ... add other private include paths required here ...
});
PublicDependencyModuleNames.AddRange(
new string[]
{
"Core",
"VaRestPlugin"
// ... add other public dependencies that you statically link with here ...
});
PrivateDependencyModuleNames.AddRange(
new string[]
{
"CoreUObject",
"Engine",
"Slate",
"SlateCore",
"InputCore",
"AssetTools",
"UnrealEd", // for FAssetEditorManager
"KismetWidgets",
"KismetCompiler",
"BlueprintGraph",
"GraphEditor",
"Kismet", // for FWorkflowCentricApplication
"PropertyEditor",
"EditorStyle",
"Sequencer",
"DetailCustomizations",
"Settings",
"RenderCore"
});
DynamicallyLoadedModuleNames.AddRange(
new string[]
{
// ... add any modules that your module loads dynamically here ...
});
}
public FriendsAndChat(TargetInfo Target)
{
PublicDependencyModuleNames.AddRange(
new string[]
{
"Core",
"CoreUObject",
"InputCore",
"Slate",
"OnlineSubsystem"
}
);
PrivateDependencyModuleNames.AddRange(
new string[]
{
"SlateCore",
"Sockets",
"OnlineSubsystem"
}
);
PrivateIncludePaths.AddRange(
new string[]
{
"Developer/FriendsAndChat/Private",
"Developer/FriendsAndChat/Private/UI/Widgets",
"Developer/FriendsAndChat/Private/Models",
"Developer/FriendsAndChat/Private/Core",
}
);
PublicIncludePaths.AddRange(
new string[]
{
"Developer/FriendsAndChat/Public/Models",
"Developer/FriendsAndChat/Public/Interfaces"
}
);
DynamicallyLoadedModuleNames.AddRange(
new string[] {
"HTTP",
"Analytics",
"AnalyticsET",
"EditorStyle",
"OnlineSubsystem"
}
);
PrivateIncludePathModuleNames.AddRange(
new string[] {
"HTTP",
"Analytics",
"AnalyticsET",
"EditorStyle",
}
);
if (UEBuildConfiguration.bCompileMcpOSS == true)
{
PublicDependencyModuleNames.AddRange(
new string[]
{
"OnlineSubsystemMcp",
}
);
PrivateDependencyModuleNames.AddRange(
new string[]
{
"OnlineSubsystemMcp",
}
);
DynamicallyLoadedModuleNames.AddRange(
new string[]
{
"OnlineSubsystemMcp",
}
);
}
}
public AdvancePakSSL(ReadOnlyTargetRules Target) : base(Target)
{
Type = ModuleType.External;
string OpenSSL101sPath = Path.Combine(Target.UEThirdPartySourceDirectory, "OpenSSL", "1_0_1s");
string OpenSSL111Path = Path.Combine(Target.UEThirdPartySourceDirectory, "OpenSSL", "1.1.1");
string OpenSSL111dPath = Path.Combine(Target.UEThirdPartySourceDirectory, "OpenSSL", "1.1.1c");
string PlatformSubdir = Target.Platform.ToString();
string ConfigFolder = (Target.Configuration == UnrealTargetConfiguration.Debug && Target.bDebugBuildsActuallyUseDebugCRT) ? "Debug" : "Release";
if (Target.Platform == UnrealTargetPlatform.Mac || Target.Platform == UnrealTargetPlatform.IOS)
{
PublicIncludePaths.Add(Path.Combine(OpenSSL111Path, "Include", PlatformSubdir));
string LibPath = Path.Combine(OpenSSL111Path, "Lib", PlatformSubdir);
PublicAdditionalLibraries.Add(Path.Combine(LibPath, "libssl.a"));
PublicAdditionalLibraries.Add(Path.Combine(LibPath, "libcrypto.a"));
}
else if (Target.Platform == UnrealTargetPlatform.PS4)
{
string IncludePath = Target.UEThirdPartySourceDirectory + "OpenSSL/1.0.2g" + "/" + "include/PS4";
string LibraryPath = Target.UEThirdPartySourceDirectory + "OpenSSL/1.0.2g" + "/" + "lib/PS4/Release";
PublicIncludePaths.Add(IncludePath);
PublicAdditionalLibraries.Add(LibraryPath + "/" + "libssl.a");
PublicAdditionalLibraries.Add(LibraryPath + "/" + "libcrypto.a");
}
else if (Target.Platform == UnrealTargetPlatform.Win64 || Target.Platform == UnrealTargetPlatform.Win32 ||
Target.Platform == UnrealTargetPlatform.HoloLens)
{
// Our OpenSSL 1.1.1 libraries are built with zlib compression support
PrivateDependencyModuleNames.Add("zlib");
string VSVersion = "VS" + Target.WindowsPlatform.GetVisualStudioCompilerVersionName();
// Add includes
PublicIncludePaths.Add(Path.Combine(OpenSSL111Path, "include", PlatformSubdir, VSVersion));
// Add Libs
string LibPath = Path.Combine(OpenSSL111Path, "lib", PlatformSubdir, VSVersion, ConfigFolder);
PublicAdditionalLibraries.Add(Path.Combine(LibPath, "libssl.lib"));
PublicAdditionalLibraries.Add(Path.Combine(LibPath, "libcrypto.lib"));
PublicSystemLibraries.Add("crypt32.lib");
}
else if (Target.IsInPlatformGroup(UnrealPlatformGroup.Unix))
{
string platform = "/Linux/" + Target.Architecture;
string IncludePath = OpenSSL111dPath + "/include" + platform;
string LibraryPath = OpenSSL111dPath + "/lib" + platform;
PublicIncludePaths.Add(IncludePath);
PublicAdditionalLibraries.Add(LibraryPath + "/libssl.a");
PublicAdditionalLibraries.Add(LibraryPath + "/libcrypto.a");
PublicDependencyModuleNames.Add("zlib");
// PublicAdditionalLibraries.Add("z");
}
else if (Target.Platform == UnrealTargetPlatform.Android || Target.Platform == UnrealTargetPlatform.Lumin)
{
string IncludePath = OpenSSL101sPath + "/include/Android";
PublicIncludePaths.Add(IncludePath);
// unneeded since included in libcurl
// string LibPath = Path.Combine(OpenSSL101sPath, "lib", PlatformSubdir);
//PublicLibraryPaths.Add(LibPath);
}
}
public USDImporter(ReadOnlyTargetRules Target) : base(Target)
{
// We require the whole editor to be RTTI enabled on Linux for now
if (Target.Platform != UnrealTargetPlatform.Linux)
{
bUseRTTI = true;
}
PrivateDependencyModuleNames.AddRange(
new string[]
{
"Core",
"CoreUObject",
"Engine",
"JsonUtilities",
"UnrealEd",
"InputCore",
"SlateCore",
"PropertyEditor",
"Slate",
"EditorStyle",
"RawMesh",
"GeometryCache",
"MeshDescription",
"MeshUtilities",
"MessageLog",
"PythonScriptPlugin",
"RenderCore",
"RHI",
"StaticMeshDescription",
"UnrealUSDWrapper",
"USDUtilities",
}
);
// Always use the official version of IntelTBB
string IntelTBBLibs = Target.UEThirdPartySourceDirectory + "IntelTBB/IntelTBB-2019u8/lib/";
if (Target.Platform == UnrealTargetPlatform.Win64)
{
PrivateDependencyModuleNames.Add("UnrealUSDWrapper");
foreach (string FilePath in Directory.EnumerateFiles(Path.Combine(ModuleDirectory, "../../Binaries/Win64/"), "*.dll", SearchOption.AllDirectories))
{
RuntimeDependencies.Add(FilePath);
}
RuntimeDependencies.Add(IntelTBBLibs + "Win64/vc14/tbb.dll");
}
else if (Target.Platform == UnrealTargetPlatform.Linux && Target.Architecture.StartsWith("x86_64"))
{
PrivateDependencyModuleNames.Add("UnrealUSDWrapper");
// link directly to runtime libs on Linux, as this also puts them into rpath
string RuntimeLibraryPath = Path.Combine(ModuleDirectory, "../../Binaries", Target.Platform.ToString(), Target.Architecture.ToString());
PrivateRuntimeLibraryPaths.Add(RuntimeLibraryPath);
RuntimeDependencies.Add(IntelTBBLibs + "Linux/libtbb.so");
RuntimeDependencies.Add(IntelTBBLibs + "Linux/libtbb.so.2");
RuntimeDependencies.Add(IntelTBBLibs + "Linux/libtbbmalloc.so");
RuntimeDependencies.Add(IntelTBBLibs + "Linux/libtbbmalloc.so.2");
foreach (string FilePath in Directory.EnumerateFiles(RuntimeLibraryPath, "*.so*", SearchOption.AllDirectories))
{
RuntimeDependencies.Add(FilePath);
}
}
}
public FMODStudio(TargetInfo Target)
#endif
{
PCHUsage = PCHUsageMode.UseExplicitOrSharedPCHs;
PrivatePCHHeaderFile = "Private/FMODStudioPrivatePCH.h";
bFasterWithoutUnity = true;
PublicIncludePaths.Add(Path.Combine(ModuleDirectory, "Public/FMOD"));
PrivateIncludePaths.Add(Path.Combine(ModuleDirectory, "Classes"));
PublicDependencyModuleNames.AddRange(
new string[]
{
"Core",
"CoreUObject",
"Engine",
"Media",
"Projects"
}
);
PrivateDependencyModuleNames.AddRange(
new string[]
{
"MovieScene",
"MovieSceneTracks"
}
);
if (Target.bBuildEditor == true)
{
PrivateDependencyModuleNames.Add("AssetRegistry");
PrivateDependencyModuleNames.Add("UnrealEd");
PrivateDependencyModuleNames.Add("Settings");
}
DynamicallyLoadedModuleNames.AddRange(
new string[]
{
}
);
string configName = "";
if (Target.Configuration != UnrealTargetConfiguration.Shipping)
{
configName = "L";
PublicDefinitions.Add("FMODSTUDIO_LINK_LOGGING=1");
}
else
{
configName = "";
PublicDefinitions.Add("FMODSTUDIO_LINK_RELEASE=1");
}
string platformName = Target.Platform.ToString();
string linkExtension = "";
string dllExtension = "";
string libPrefix = "";
// ModuleDirectory points to FMODStudio\source\FMODStudio, need to get back to binaries directory for our libs
string BasePath = System.IO.Path.Combine(ModuleDirectory, "../../Binaries", platformName);
// Collapse the directory path, otherwise OSX is having issues with plugin paths.
BasePath = Utils.CleanDirectorySeparators(BasePath);
string copyThirdPartyPath = "";
bool bAddRuntimeDependencies = true;
bool bAddDelayLoad = false;
bool bShortLinkNames = false;
bool bLinkFromBinaries = true;
// Minimum UE version for Switch 4.15
System.Console.WriteLine("Target Platform -- " + Target.Platform.ToString());
if (Target.Platform == UnrealTargetPlatform.Switch)
{
linkExtension = ".a";
dllExtension = ".a";
libPrefix = "lib";
bAddRuntimeDependencies = false;
}
else if (Target.Platform.ToString() == "UWP64")
{
linkExtension = ".lib";
dllExtension = ".dll";
bAddDelayLoad = true;
}
else if (Target.Platform == UnrealTargetPlatform.Win32)
{
linkExtension = "_vc.lib";
dllExtension = ".dll";
bAddDelayLoad = true;
}
else if (Target.Platform == UnrealTargetPlatform.Win64)
{
linkExtension = "_vc.lib";
dllExtension = ".dll";
bAddDelayLoad = true;
}
else if (Target.Platform == UnrealTargetPlatform.Mac)
{
linkExtension = dllExtension = ".dylib";
libPrefix = "lib";
bLinkFromBinaries = false;
}
else if (Target.Platform == UnrealTargetPlatform.XboxOne)
{
linkExtension = "_vc.lib";
dllExtension = ".dll";
copyThirdPartyPath = "../XBoxOne"; // XBoxOne still doesn't seem to support plugins with .dlls
bAddDelayLoad = false;
}
else if (Target.Platform == UnrealTargetPlatform.PS4)
{
linkExtension = "_stub.a";
dllExtension = ".prx";
libPrefix = "lib";
bAddDelayLoad = true;
}
else if (Target.Platform == UnrealTargetPlatform.Android)
{
// Don't use an explicit path with the .so, let the architecture dirs be filtered by UBT
PublicLibraryPaths.Add(System.IO.Path.Combine(BasePath, "armeabi-v7a"));
PublicLibraryPaths.Add(System.IO.Path.Combine(BasePath, "arm64-v8a"));
PublicLibraryPaths.Add(System.IO.Path.Combine(BasePath, "x86"));
bAddRuntimeDependencies = false; // Don't use this system
bShortLinkNames = true; // strip off lib and .so
linkExtension = dllExtension = ".so";
libPrefix = "lib";
}
else if (Target.Platform == UnrealTargetPlatform.IOS)
{
linkExtension = "_iphoneos.a";
libPrefix = "lib";
bAddRuntimeDependencies = false;
}
else if (Target.Platform == UnrealTargetPlatform.TVOS)
{
linkExtension = "_appletvos.a";
libPrefix = "lib";
bAddRuntimeDependencies = false;
}
else if (Target.Platform == UnrealTargetPlatform.Linux)
{
BasePath = System.IO.Path.Combine(BasePath, "x86_64");
linkExtension = ".so";
dllExtension = ".so";
libPrefix = "lib";
}
else if (Target.Platform.ToString() == "Stadia")
{
linkExtension = ".so";
dllExtension = ".so";
libPrefix = "lib";
}
else
{
//extName = ".a";
throw new System.Exception(System.String.Format("Unsupported platform {0}", Target.Platform.ToString()));
//break;
}
//System.Console.WriteLine("FMOD Current path: " + System.IO.Path.GetFullPath("."));
//System.Console.WriteLine("FMOD Base path: " + BasePath);
PublicLibraryPaths.Add(BasePath);
string fmodLibName = System.String.Format("{0}fmod{1}{2}", libPrefix, configName, linkExtension);
string fmodStudioLibName = System.String.Format("{0}fmodstudio{1}{2}", libPrefix, configName, linkExtension);
string fmodDllName = System.String.Format("{0}fmod{1}{2}", libPrefix, configName, dllExtension);
string fmodStudioDllName = System.String.Format("{0}fmodstudio{1}{2}", libPrefix, configName, dllExtension);
string fmodLibPath = System.IO.Path.Combine(BasePath, fmodLibName);
string fmodStudioLibPath = System.IO.Path.Combine(BasePath, fmodStudioLibName);
string fmodDllPath = System.IO.Path.Combine(BasePath, fmodDllName);
string fmodStudioDllPath = System.IO.Path.Combine(BasePath, fmodStudioDllName);
System.Collections.Generic.List <string> plugins = GetPlugins(BasePath);
if (bShortLinkNames)
{
// For android we have provided the paths to all architectures above
// Just provide the name without "lib" and without extension
PublicAdditionalLibraries.Add(System.String.Format("fmod{0}", configName));
PublicAdditionalLibraries.Add(System.String.Format("fmodstudio{0}", configName));
}
else if (bLinkFromBinaries)
{
PublicAdditionalLibraries.Add(fmodLibPath);
PublicAdditionalLibraries.Add(fmodStudioLibPath);
}
else
{
string LibPath = System.IO.Path.Combine(ModuleDirectory, "../../Libs/Mac/");
PublicAdditionalLibraries.Add(System.String.Format("{0}libfmod{1}.dylib", LibPath, configName));
PublicAdditionalLibraries.Add(System.String.Format("{0}libfmodStudio{1}.dylib", LibPath, configName));
}
if (bAddRuntimeDependencies)
{
RuntimeDependencies.Add(fmodDllPath);
RuntimeDependencies.Add(fmodStudioDllPath);
foreach (string plugin in plugins)
{
string pluginPath = System.IO.Path.Combine(BasePath, plugin + dllExtension);
System.Console.WriteLine("Adding reference to FMOD plugin: " + pluginPath);
RuntimeDependencies.Add(pluginPath);
}
}
if (copyThirdPartyPath.Length != 0)
{
string destPath = System.IO.Path.Combine(Target.UEThirdPartyBinariesDirectory, copyThirdPartyPath);
System.IO.Directory.CreateDirectory(destPath);
string fmodDllDest = System.IO.Path.Combine(destPath, fmodDllName);
string fmodStudioDllDest = System.IO.Path.Combine(destPath, fmodStudioDllName);
CopyFile(fmodDllPath, fmodDllDest);
CopyFile(fmodStudioDllPath, fmodStudioDllDest);
}
if (bAddDelayLoad)
{
PublicDelayLoadDLLs.AddRange(
new string[] {
fmodDllName,
fmodStudioDllName
}
);
}
if (Target.Platform == UnrealTargetPlatform.Android)
{
string APLName = System.String.Format("FMODStudio{0}_APL.xml", configName);
string RelAPLPath = Utils.MakePathRelativeTo(System.IO.Path.Combine(ModuleDirectory, APLName), Target.RelativeEnginePath);
System.Console.WriteLine("Adding {0}", RelAPLPath);
AdditionalPropertiesForReceipt.Add("AndroidPlugin", RelAPLPath);
foreach (string PluginName in System.IO.Directory.GetFiles(BasePath))
{
if (PluginName.EndsWith("_APL.xml", System.StringComparison.OrdinalIgnoreCase))
{
string RelPluginPath = Utils.MakePathRelativeTo(PluginName, Target.RelativeEnginePath);
System.Console.WriteLine("Adding {0}", RelPluginPath);
AdditionalPropertiesForReceipt.Add("AndroidPlugin", RelPluginPath);
}
}
}
}
public HotPatcherEditor(ReadOnlyTargetRules Target) : base(Target)
{
PCHUsage = ModuleRules.PCHUsageMode.UseExplicitOrSharedPCHs;
PublicIncludePaths.AddRange(
new string[] {
// ... add public include paths required here ...
}
);
PrivateIncludePaths.AddRange(
new string[] {
// ... add other private include paths required here ...
}
);
PublicDependencyModuleNames.AddRange(
new string[]
{
"Core",
"Json",
"TargetPlatform",
"PropertyEditor",
"AssetManagerEx",
"PakFileUtilities"
// ... add other public dependencies that you statically link with here ...
}
);
PrivateDependencyModuleNames.AddRange(
new string[]
{
"Core",
"Projects",
"DesktopPlatform",
"InputCore",
"UnrealEd",
"EditorStyle",
"LevelEditor",
"CoreUObject",
"Engine",
"Slate",
"SlateCore",
"HotPatcherRuntime"
// ... add private dependencies that you statically link with here ...
}
);
DynamicallyLoadedModuleNames.AddRange(
new string[]
{
// ... add any modules that your module loads dynamically here ...
}
);
OptimizeCode = CodeOptimization.InShippingBuildsOnly;
}
public TargetPlatform(TargetInfo Target)
{
PrivateDependencyModuleNames.Add("Core");
PublicDependencyModuleNames.Add("DesktopPlatform");
PrivateIncludePathModuleNames.Add("PhysXFormats");
// no need for all these modules if the program doesn't want developer tools at all (like UnrealFileServer)
if (!UEBuildConfiguration.bBuildRequiresCookedData && UEBuildConfiguration.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 (UEBuildConfiguration.bCompileLeanAndMeanUE == false)
{
DynamicallyLoadedModuleNames.Add("TextureFormatIntelISPCTexComp");
}
}
if (Target.Platform == UnrealTargetPlatform.Win32 ||
Target.Platform == UnrealTargetPlatform.Win64 ||
(Target.Platform == UnrealTargetPlatform.HTML5 && Target.Architecture == "-win32"))
{
// these are needed by multiple platform specific target platforms, so we make sure they are built with the base editor
DynamicallyLoadedModuleNames.Add("ShaderFormatD3D");
if (UEBuildConfiguration.bCompileLeanAndMeanUE == false)
{
DynamicallyLoadedModuleNames.Add("TextureFormatDXT");
DynamicallyLoadedModuleNames.Add("TextureFormatPVR");
DynamicallyLoadedModuleNames.Add("TextureFormatASTC");
}
DynamicallyLoadedModuleNames.Add("TextureFormatUncompressed");
if (UEBuildConfiguration.bCompileAgainstEngine)
{
DynamicallyLoadedModuleNames.Add("AudioFormatADPCM"); // For IOS cooking
DynamicallyLoadedModuleNames.Add("AudioFormatOgg");
DynamicallyLoadedModuleNames.Add("AudioFormatOpus");
}
if (Target.Type == TargetRules.TargetType.Editor || Target.Type == TargetRules.TargetType.Program)
{
DynamicallyLoadedModuleNames.Add("AndroidTargetPlatform");
DynamicallyLoadedModuleNames.Add("Android_PVRTCTargetPlatform");
DynamicallyLoadedModuleNames.Add("Android_ATCTargetPlatform");
DynamicallyLoadedModuleNames.Add("Android_DXTTargetPlatform");
DynamicallyLoadedModuleNames.Add("Android_ETC1TargetPlatform");
DynamicallyLoadedModuleNames.Add("Android_ETC2TargetPlatform");
DynamicallyLoadedModuleNames.Add("Android_ASTCTargetPlatform");
DynamicallyLoadedModuleNames.Add("Android_MultiTargetPlatform");
DynamicallyLoadedModuleNames.Add("IOSTargetPlatform");
DynamicallyLoadedModuleNames.Add("HTML5TargetPlatform");
}
}
else if (Target.Platform == UnrealTargetPlatform.Mac)
{
if (UEBuildConfiguration.bCompileLeanAndMeanUE == false)
{
DynamicallyLoadedModuleNames.Add("TextureFormatDXT");
DynamicallyLoadedModuleNames.Add("TextureFormatPVR");
DynamicallyLoadedModuleNames.Add("TextureFormatASTC");
}
DynamicallyLoadedModuleNames.Add("TextureFormatUncompressed");
if (UEBuildConfiguration.bCompileAgainstEngine)
{
DynamicallyLoadedModuleNames.Add("AudioFormatOgg");
DynamicallyLoadedModuleNames.Add("AudioFormatOpus");
}
if (Target.Type == TargetRules.TargetType.Editor || Target.Type == TargetRules.TargetType.Program)
{
DynamicallyLoadedModuleNames.Add("AndroidTargetPlatform");
DynamicallyLoadedModuleNames.Add("Android_MultiTargetPlatform");
DynamicallyLoadedModuleNames.Add("Android_PVRTCTargetPlatform");
DynamicallyLoadedModuleNames.Add("Android_ATCTargetPlatform");
DynamicallyLoadedModuleNames.Add("Android_DXTTargetPlatform");
DynamicallyLoadedModuleNames.Add("Android_ETC1TargetPlatform");
DynamicallyLoadedModuleNames.Add("Android_ETC2TargetPlatform");
DynamicallyLoadedModuleNames.Add("IOSTargetPlatform");
DynamicallyLoadedModuleNames.Add("HTML5TargetPlatform");
}
}
else if (Target.Platform == UnrealTargetPlatform.Linux)
{
if (UEBuildConfiguration.bCompileLeanAndMeanUE == false)
{
DynamicallyLoadedModuleNames.Add("TextureFormatDXT");
DynamicallyLoadedModuleNames.Add("TextureFormatPVR");
DynamicallyLoadedModuleNames.Add("TextureFormatASTC");
}
DynamicallyLoadedModuleNames.Add("TextureFormatUncompressed");
if (UEBuildConfiguration.bCompileAgainstEngine)
{
DynamicallyLoadedModuleNames.Add("AudioFormatOgg");
DynamicallyLoadedModuleNames.Add("AudioFormatOpus");
}
}
}
if (UEBuildConfiguration.bBuildDeveloperTools == true && (UEBuildConfiguration.bBuildRequiresCookedData || UEBuildConfiguration.bRuntimePhysicsCooking) && UEBuildConfiguration.bCompileAgainstEngine && UEBuildConfiguration.bCompilePhysX)
{
DynamicallyLoadedModuleNames.Add("PhysXFormats");
}
}
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
}
);
PrivateDependencyModuleNames.AddRange(
new string[] {
"AppFramework",
"ApplicationCore",
"CinematicCamera",
"Core",
"CoreUObject",
"InputCore",
"Engine",
"Slate",
"SlateCore",
"EditorStyle",
"UnrealEd",
"MovieScene",
"MovieSceneTracks",
"MovieSceneTools",
"MovieSceneCapture",
"MovieSceneCaptureDialog",
"EditorWidgets",
"SequencerWidgets",
"BlueprintGraph",
"LevelSequence",
"GraphEditor",
"ViewportInteraction"
}
);
CircularlyReferencedDependentModules.AddRange(
new string[]
{
"ViewportInteraction",
}
);
PrivateIncludePathModuleNames.AddRange(
new string[] {
"ContentBrowser",
"PropertyEditor",
"Kismet",
"SequenceRecorder",
"LevelEditor",
"MainFrame",
"DesktopPlatform"
}
);
PublicIncludePathModuleNames.AddRange(
new string[] {
"PropertyEditor",
"SceneOutliner",
}
);
DynamicallyLoadedModuleNames.AddRange(
new string[] {
"PropertyEditor",
"LevelEditor",
"SceneOutliner",
"WorkspaceMenuStructure",
"SequenceRecorder",
"SequenceRecorderSections",
"MainFrame",
}
);
CircularlyReferencedDependentModules.Add("MovieSceneTools");
AddEngineThirdPartyPrivateStaticDependencies(Target, "FBX");
}
public MainFrame(ReadOnlyTargetRules Target) : base(Target)
{
PublicDependencyModuleNames.AddRange(
new string[]
{
"Documentation",
}
);
PrivateDependencyModuleNames.AddRange(
new string[] {
"Core",
"CoreUObject",
"ApplicationCore",
"Engine",
"EngineSettings",
"InputCore",
"RHI",
"RenderCore",
"Slate",
"SlateCore",
"EditorStyle",
"SourceControl",
"SourceControlWindows",
"TargetPlatform",
"DesktopPlatform",
"UnrealEd",
"WorkspaceMenuStructure",
"MessageLog",
"UATHelper",
"TranslationEditor",
"Projects",
"DeviceProfileEditor",
"UndoHistory",
"Analytics",
}
);
PrivateIncludePathModuleNames.AddRange(
new string[] {
"AssetTools",
"DesktopPlatform",
"GameProjectGeneration",
"ProjectTargetPlatformEditor",
"LevelEditor",
"OutputLog",
"Settings",
"SourceCodeAccess",
"Toolbox",
"LocalizationDashboard",
}
);
PrivateIncludePaths.AddRange(
new string[] {
"Editor/MainFrame/Private",
"Editor/MainFrame/Private/Frame",
"Editor/MainFrame/Private/Menus",
}
);
DynamicallyLoadedModuleNames.AddRange(
new string[] {
"AssetTools",
"GameProjectGeneration",
"ProjectTargetPlatformEditor",
"LevelEditor",
"OutputLog",
"SourceCodeAccess",
"HotReload",
"LocalizationDashboard",
}
);
}
public MicrosoftOpenXR(ReadOnlyTargetRules Target) : base(Target)
{
if (Target.Platform == UnrealTargetPlatform.Win64 || Target.Platform == UnrealTargetPlatform.HoloLens)
{
// these parameters mandatory for winrt support
bEnableExceptions = true;
bUseUnity = false;
CppStandard = CppStandardVersion.Cpp17;
PublicSystemLibraries.AddRange(new string[] { "shlwapi.lib", "runtimeobject.lib" });
}
PCHUsage = ModuleRules.PCHUsageMode.UseExplicitOrSharedPCHs;
PrivatePCHHeaderFile = @"Private\OpenXRCommon.h";
PrivateIncludePaths.AddRange(
new string[] {
// This private include path ensures our newer copy of the openxr headers take precedence over the engine's copy.
"MicrosoftOpenXR/Private/External"
}
);
PrivateDependencyModuleNames.AddRange(
new string[]
{
"Core",
"CoreUObject",
"ApplicationCore",
"Engine",
"Slate",
"SlateCore",
"InputCore",
"OpenXRHMD",
"MicrosoftOpenXRRuntimeSettings",
"HeadMountedDisplay",
"AugmentedReality",
"OpenXRAR",
"RHI",
"RenderCore",
"Projects",
"NuGetModule"
}
);
PublicDependencyModuleNames.AddRange(
new string[]
{
"NuGetModule"
}
);
if (Target.bBuildEditor)
{
PrivateDependencyModuleNames.AddRange(
new string[]
{
"UnrealEd"
}
);
}
PrivateIncludePathModuleNames.AddRange(
new string[]
{
"HeadMountedDisplay",
"NuGetModule"
}
);
PublicIncludePathModuleNames.AddRange(
new string[]
{
"HeadMountedDisplay",
"NuGetModule"
}
);
// DX-specific code for webcam texture processing
if (Target.Platform == UnrealTargetPlatform.Win64 || Target.Platform == UnrealTargetPlatform.HoloLens)
{
PrivateDependencyModuleNames.AddRange(new string[] {
"D3D11RHI",
"D3D12RHI"
});
var EngineDir = Path.GetFullPath(Target.RelativeEnginePath);
PrivateIncludePaths.AddRange(
new string[] {
Path.Combine(EngineDir, @"Source\Runtime\Windows\D3D11RHI\Private"),
Path.Combine(EngineDir, @"Source\Runtime\Windows\D3D11RHI\Private\Windows"),
Path.Combine(EngineDir, @"Source\Runtime\D3D12RHI\Private"),
Path.Combine(EngineDir, @"Source\Runtime\D3D12RHI\Private\Windows")
});
AddEngineThirdPartyPrivateStaticDependencies(Target, "DX11");
AddEngineThirdPartyPrivateStaticDependencies(Target, "DX12");
AddEngineThirdPartyPrivateStaticDependencies(Target, "NVAPI");
AddEngineThirdPartyPrivateStaticDependencies(Target, "AMD_AGS");
AddEngineThirdPartyPrivateStaticDependencies(Target, "NVAftermath");
AddEngineThirdPartyPrivateStaticDependencies(Target, "IntelMetricsDiscovery");
AddEngineThirdPartyPrivateStaticDependencies(Target, "IntelExtensionsFramework");
}
}
public VulkanRHI(ReadOnlyTargetRules Target) : base(Target)
{
bOutputPubliclyDistributable = true;
PrivateIncludePaths.Add("Runtime/VulkanRHI/Private");
if (Target.Platform == UnrealTargetPlatform.Win32 || Target.Platform == UnrealTargetPlatform.Win64)
{
PrivateIncludePaths.Add("Runtime/VulkanRHI/Private/Windows");
}
else
{
PrivateIncludePaths.Add("Runtime/VulkanRHI/Private/" + Target.Platform);
}
PrivateDependencyModuleNames.AddRange(
new string[]
{
"Core",
"CoreUObject",
"Engine",
"RHI",
"RenderCore",
"ShaderCore",
"UtilityShaders",
"HeadMountedDisplay",
}
);
if (Target.Platform == UnrealTargetPlatform.Win32 || Target.Platform == UnrealTargetPlatform.Win64 ||
Target.Platform == UnrealTargetPlatform.Android || Target.Platform == UnrealTargetPlatform.Lumin)
{
AddEngineThirdPartyPrivateStaticDependencies(Target, "Vulkan");
}
else if (Target.IsInPlatformGroup(UnrealPlatformGroup.Unix))
{
if (Target.Platform == UnrealTargetPlatform.Linux)
{
AddEngineThirdPartyPrivateStaticDependencies(Target, "SDL2");
string VulkanSDKPath = Environment.GetEnvironmentVariable("VULKAN_SDK");
bool bSDKInstalled = !String.IsNullOrEmpty(VulkanSDKPath);
if (BuildHostPlatform.Current.Platform != UnrealTargetPlatform.Linux || !bSDKInstalled)
{
AddEngineThirdPartyPrivateStaticDependencies(Target, "Vulkan");
}
else
{
PrivateIncludePaths.Add(VulkanSDKPath + "/include");
PrivateIncludePaths.Add(VulkanSDKPath + "/include/vulkan");
PublicLibraryPaths.Add(VulkanSDKPath + "/lib");
PublicAdditionalLibraries.Add("vulkan");
}
}
else
{
AddEngineThirdPartyPrivateStaticDependencies(Target, "VkHeadersExternal");
}
}
else if (Target.Platform == UnrealTargetPlatform.Mac)
{
string VulkanSDKPath = Environment.GetEnvironmentVariable("VULKAN_SDK");
bool bHaveVulkan = false;
if (!String.IsNullOrEmpty(VulkanSDKPath))
{
bHaveVulkan = true;
PrivateIncludePaths.Add(VulkanSDKPath + "/Include");
}
if (bHaveVulkan)
{
if (Target.Configuration != UnrealTargetConfiguration.Shipping)
{
PrivateIncludePathModuleNames.AddRange(
new string[]
{
"TaskGraph",
}
);
}
}
else
{
PrecompileForTargets = PrecompileTargetsType.None;
}
}
else
{
PrecompileForTargets = PrecompileTargetsType.None;
}
}
public SandboxFile(TargetInfo Target)
{
PrivateDependencyModuleNames.Add("Core");
}
public TranslationEditor(TargetInfo Target)
{
PublicIncludePathModuleNames.Add("LevelEditor");
PublicIncludePathModuleNames.Add("WorkspaceMenuStructure");
PrivateIncludePathModuleNames.Add("LocalizationService");
PrivateIncludePathModuleNames.AddRange(
new string[] {
"DesktopPlatform",
"MessageLog",
}
);
PrivateDependencyModuleNames.AddRange(
new string[] {
"Core",
"CoreUObject",
"Engine",
"InputCore",
"Internationalization",
"Json",
"PropertyEditor",
"Slate",
"SlateCore",
"EditorStyle",
"UnrealEd",
"GraphEditor",
"SourceControl",
"MessageLog",
"Documentation",
"Localization",
"LocalizationService",
}
);
PublicDependencyModuleNames.AddRange(
new string[] {
"Core",
"CoreUObject",
"Engine",
"Localization",
}
);
DynamicallyLoadedModuleNames.AddRange(
new string[] {
"WorkspaceMenuStructure",
"DesktopPlatform",
}
);
PrivateIncludePaths.AddRange(
new string[]
{
"Editor/TranslationEditor/Private",
}
);
PublicIncludePaths.AddRange(
new string[]
{
"Editor/TranslationEditor/Public",
}
);
}
