public MeshUtilities(ReadOnlyTargetRules Target) : base(Target)
{
PublicDependencyModuleNames.AddRange(
new string[] {
"MaterialUtilities",
}
);
PrivateDependencyModuleNames.AddRange(
new string[] {
"Core",
"CoreUObject",
"Engine",
"RawMesh",
"RenderCore", // For FPackedNormal
"SlateCore",
"Slate",
"MaterialUtilities",
"MeshBoneReduction",
"UnrealEd",
"RHI",
"HierarchicalLODUtilities",
"Landscape",
"LevelEditor",
"PropertyEditor",
"EditorStyle",
"GraphColor",
"MeshBuilderCommon",
"MeshUtilitiesCommon",
"MeshDescription",
"StaticMeshDescription",
"MeshDescriptionOperations"
}
);
PublicIncludePathModuleNames.AddRange(
new string[] {
"MeshMergeUtilities"
}
);
PrivateIncludePathModuleNames.AddRange(
new string[] {
"AnimationBlueprintEditor",
"AnimationEditor",
"MeshMergeUtilities",
"MaterialBaking",
"Persona",
"SkeletalMeshEditor",
}
);
DynamicallyLoadedModuleNames.AddRange(
new string[] {
"AnimationBlueprintEditor",
"AnimationEditor",
"MeshMergeUtilities",
"MaterialBaking",
"SkeletalMeshEditor",
}
);
AddEngineThirdPartyPrivateStaticDependencies(Target, "nvTriStrip");
AddEngineThirdPartyPrivateStaticDependencies(Target, "ForsythTriOptimizer");
AddEngineThirdPartyPrivateStaticDependencies(Target, "QuadricMeshReduction");
AddEngineThirdPartyPrivateStaticDependencies(Target, "MikkTSpace");
AddEngineThirdPartyPrivateStaticDependencies(Target, "nvTessLib");
if ((Target.Platform == UnrealTargetPlatform.Win64) || (Target.Platform == UnrealTargetPlatform.Win32))
{
AddEngineThirdPartyPrivateStaticDependencies(Target, "DX9");
}
// EMBREE
if (Target.Platform == UnrealTargetPlatform.Win64)
{
string SDKDir = Target.UEThirdPartySourceDirectory + "IntelEmbree/Embree2140/Win64/";
PublicIncludePaths.Add(SDKDir + "include");
PublicAdditionalLibraries.Add(SDKDir + "lib/embree.2.14.0.lib");
RuntimeDependencies.Add("$(TargetOutputDir)/embree.2.14.0.dll", SDKDir + "lib/embree.2.14.0.dll");
RuntimeDependencies.Add("$(TargetOutputDir)/tbb.dll", SDKDir + "lib/tbb.dll");
RuntimeDependencies.Add("$(TargetOutputDir)/tbbmalloc.dll", SDKDir + "lib/tbbmalloc.dll");
PublicDefinitions.Add("USE_EMBREE=1");
}
else if (Target.Platform == UnrealTargetPlatform.Mac)
{
string SDKDir = Target.UEThirdPartySourceDirectory + "IntelEmbree/Embree2140/MacOSX/";
PublicIncludePaths.Add(SDKDir + "include");
PublicAdditionalLibraries.Add(SDKDir + "lib/libembree.2.14.0.dylib");
PublicAdditionalLibraries.Add(SDKDir + "lib/libtbb.dylib");
PublicAdditionalLibraries.Add(SDKDir + "lib/libtbbmalloc.dylib");
RuntimeDependencies.Add("$(TargetOutputDir)/libembree.2.14.0.dylib", SDKDir + "lib/libembree.2.14.0.dylib");
RuntimeDependencies.Add("$(TargetOutputDir)/libtbb.dylib", SDKDir + "lib/libtbb.dylib");
RuntimeDependencies.Add("$(TargetOutputDir)/libtbbmalloc.dylib", SDKDir + "lib/libtbbmalloc.dylib");
PublicDefinitions.Add("USE_EMBREE=1");
}
else
{
PublicDefinitions.Add("USE_EMBREE=0");
}
}
public ProductivityPlugin(TargetInfo Target)
{
PublicIncludePaths.AddRange(
new string[] {
"ProductivityPlugin/Classes"
// ... add public include paths required here ...
}
);
PrivateIncludePaths.AddRange(
new string[] {
"ProductivityPlugin/Private",
// ... add other private include paths required here ...
}
);
PublicDependencyModuleNames.AddRange(
new string[]
{
"Core",
"CoreUObject",
"Engine",
"Slate",
"SlateCore",
"Networking",
// ... add other public dependencies that you statically link with here ...
}
);
PrivateDependencyModuleNames.AddRange(
new string[]
{
"Sockets",
}
);
if (UEBuildConfiguration.bBuildEditor)
{
PrivateDependencyModuleNames.AddRange(
new string[]
{
"UnrealEd",
"LevelEditor",
// ... add private dependencies that you statically link with here ...
}
);
}
DynamicallyLoadedModuleNames.AddRange(
new string[]
{
// ... add any modules that your module loads dynamically here ...
}
);
}
public CesiumEditor(ReadOnlyTargetRules Target) : base(Target)
{
PCHUsage = ModuleRules.PCHUsageMode.UseExplicitOrSharedPCHs;
PublicIncludePaths.AddRange(
new string[] {
// ... add public include paths required here ...
}
);
PrivateIncludePaths.AddRange(
new string[] {
Path.Combine(ModuleDirectory, "../ThirdParty/include")
}
);
string platform = Target.Platform == UnrealTargetPlatform.Win64
? "Windows-x64"
: "Unknown";
string libPath = Path.Combine(ModuleDirectory, "../ThirdParty/lib/" + platform);
string releasePostfix = "";
string debugPostfix = "d";
bool preferDebug = (Target.Configuration == UnrealTargetConfiguration.Debug || Target.Configuration == UnrealTargetConfiguration.DebugGame);
string postfix = preferDebug ? debugPostfix : releasePostfix;
string[] libs = new string[]
{
"CesiumIonClient",
"csprng"
};
if (preferDebug)
{
// We prefer Debug, but might still use Release if that's all that's available.
foreach (string lib in libs)
{
string debugPath = Path.Combine(libPath, lib + debugPostfix + ".lib");
if (!File.Exists(debugPath))
{
Console.WriteLine("Using release build of cesium-native because a debug build is not available.");
preferDebug = false;
postfix = releasePostfix;
break;
}
}
}
PublicAdditionalLibraries.AddRange(libs.Select(lib => Path.Combine(libPath, lib + postfix + ".lib")));
PublicDependencyModuleNames.AddRange(
new string[]
{
"Core",
"UnrealEd",
"CesiumRuntime"
}
);
PrivateDependencyModuleNames.AddRange(
new string[]
{
"CoreUObject",
"Engine",
"ApplicationCore",
"Slate",
"SlateCore",
"MeshDescription",
"StaticMeshDescription",
"HTTP",
"MikkTSpace",
"Chaos",
"Projects",
"InputCore",
"PropertyEditor",
"DeveloperSettings"
// ... add private dependencies that you statically link with here ...
}
);
PublicDefinitions.AddRange(
new string[]
{
}
);
DynamicallyLoadedModuleNames.AddRange(
new string[]
{
// ... add any modules that your module loads dynamically here ...
}
);
PCHUsage = PCHUsageMode.UseExplicitOrSharedPCHs;
PrivatePCHHeaderFile = "Private/PCH.h";
CppStandard = CppStandardVersion.Cpp17;
}
public QTMConnect(ReadOnlyTargetRules Target) : base(Target)
{
PrivatePCHHeaderFile = "Public/QTMConnect.h";
//PCHUsage = ModuleRules.PCHUsageMode.UseExplicitOrSharedPCHs;
string rtClientSDKPath = Path.GetFullPath(Path.Combine(PluginDirectory, "ThirdParty/RTClientSDK"));
string rtClientSDKIncludePath = System.IO.Path.Combine(rtClientSDKPath, "Include");
string targetPlatformPathName = (Target.Platform == UnrealTargetPlatform.Win32) ? "Win32" : "Win64";
string rtClientSDKLibPath = Path.Combine(rtClientSDKPath, "Lib", targetPlatformPathName);
PublicIncludePaths.AddRange(
new string[] {
"QTMConnect/Public",
// ... add public include paths required here ...
}
);
PrivateIncludePaths.AddRange(
new string[] {
"QTMConnect/Private",
rtClientSDKIncludePath,
// ... add other private include paths required here ...
}
);
// Adding your definition here, will add a global Preprocessor value for cpp
//Definitions.Add("QTM_RTCLIENTSDK_LIB_DIR=" + targetPlatformPathName/RTClientSDK + "");
PublicDependencyModuleNames.AddRange(
new string[]
{
"Core",
"Projects",
"CoreUObject",
"Engine",
// ... 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 ...
}
);
PublicSystemIncludePaths.Add(rtClientSDKIncludePath);
if (Target.Platform == UnrealTargetPlatform.Win32 ||
Target.Platform == UnrealTargetPlatform.Win64)
{
PublicLibraryPaths.Add(rtClientSDKLibPath);
PublicAdditionalLibraries.Add("RTClientSDK.lib");
}
}
public TestSlate(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",
// ... add other public dependencies that you statically link with here ...
}
);
PrivateDependencyModuleNames.AddRange(
new string[]
{
"Projects",
"InputCore",
"UnrealEd",
"LevelEditor",
"CoreUObject",
"Engine",
"Slate",
"SlateCore",
"EditorStyle",
"Json",
"JsonUtilities",
//为了资产新添加的
"AssetRegistry",
"EditorWidgets",
"ContentBrowser",
// ... add private dependencies that you statically link with here ...
}
);
PrivateIncludePathModuleNames.AddRange(
new string[]
{
"Settings",
"IntroTutorials",
}
);
DynamicallyLoadedModuleNames.AddRange(
new string[]
{
"AssetTools",
// ... add any modules that your module loads dynamically here ...
}
);
}
public SML(ReadOnlyTargetRules Target) : base(Target)
{
PCHUsage = PCHUsageMode.UseExplicitOrSharedPCHs;
bLegacyPublicIncludePaths = false;
//SML transitive dependencies
PublicDependencyModuleNames.AddRange(new[] {
"Json",
"MovieScene",
"Projects"
});
PrivateDependencyModuleNames.AddRange(new[] { "RenderCore" });
PublicDependencyModuleNames.AddRange(new string[] { "FactoryGame" });
//FactoryGame transitive dependencies
PublicDependencyModuleNames.AddRange(new[] {
"Core", "CoreUObject",
"Engine",
"InputCore",
"OnlineSubsystem", "OnlineSubsystemNull", "OnlineSubsystemEOS", "OnlineSubsystemUtils",
"SignificanceManager",
"APEX", "ApexDestruction",
"AnimGraphRuntime",
"AkAudio",
"PhysXVehicles",
"AssetRegistry",
"NavigationSystem",
"ReplicationGraph",
"AIModule",
"GameplayTasks",
"SlateCore", "Slate", "UMG",
"InstancedSplines"
});
if (Target.bBuildEditor)
{
PublicDependencyModuleNames.Add("UnrealEd");
PrivateDependencyModuleNames.Add("MainFrame");
}
var factoryGamePchPath = new DirectoryReference(Path.Combine(Target.ProjectFile.Directory.ToString(), "Source", "FactoryGame", "Public", "FactoryGame.h"));
PrivatePCHHeaderFile = factoryGamePchPath.MakeRelativeTo(new DirectoryReference(ModuleDirectory));
var thirdPartyFolder = Path.Combine(ModuleDirectory, "../../ThirdParty");
PublicIncludePaths.Add(Path.Combine(thirdPartyFolder, "include"));
var platformName = Target.Platform.ToString();
var libraryFolder = Path.Combine(thirdPartyFolder, platformName);
PublicAdditionalLibraries.Add(Path.Combine(libraryFolder, "funchook.lib"));
PublicAdditionalLibraries.Add(Path.Combine(libraryFolder, "detex.lib"));
PublicAdditionalLibraries.Add(Path.Combine(libraryFolder, "libfbxsdk-md.lib"));
PublicAdditionalLibraries.Add(Path.Combine(libraryFolder, "libxml2-md.lib"));
PublicAdditionalLibraries.Add(Path.Combine(libraryFolder, "zlib-md.lib"));
PublicAdditionalLibraries.Add(Path.Combine(libraryFolder, "AssemblyAnalyzer.lib"));
PublicAdditionalLibraries.Add(Path.Combine(libraryFolder, "Zydis.lib"));
PublicAdditionalLibraries.Add(Path.Combine(libraryFolder, "Zycore.lib"));
//Collect build metadata from the environment and pass it to C++
var currentBranch = Environment.GetEnvironmentVariable("BRANCH_NAME");
var buildId = Environment.GetEnvironmentVariable("BUILD_NUMBER");
if (currentBranch == null)
{
RetrieveHeadBranchAndCommitFromGit(Target.ProjectFile.Directory, out currentBranch, out buildId);
if (buildId != null && buildId.Length > 8)
{
buildId = buildId.Substring(0, 8);
}
}
Log.TraceInformation("Environment: Branch = {0} BuildId = {1}", currentBranch, buildId);
if (currentBranch != null && buildId != null)
{
var buildMetadataString = currentBranch == "master" ? buildId : string.Format("{0}+{1}", currentBranch, buildId);
PrivateDefinitions.Add(string.Format("SML_BUILD_METADATA=\"{0}\"", buildMetadataString));
}
}
public AzureKinectUnreal(ReadOnlyTargetRules Target) : base(Target)
{
PCHUsage = ModuleRules.PCHUsageMode.UseExplicitOrSharedPCHs;
bEnableExceptions = true;
PublicIncludePaths.AddRange(
new string[] {
// ... add public include paths required here ...
Path.Combine(ModuleDirectory, "Public")
}
);
PrivateIncludePaths.AddRange(
new string[] {
// ... add other private include paths required here ...
Path.Combine(ModuleDirectory, "Private")
}
);
PublicDependencyModuleNames.AddRange(
new string[]
{
"Core",
// ... add other public dependencies that you statically link with here ...
}
);
PrivateDependencyModuleNames.AddRange(
new string[]
{
"CoreUObject",
"Engine",
"Slate",
"SlateCore",
// ... add private dependencies that you statically link with here ...
}
);
DynamicallyLoadedModuleNames.AddRange(
new string[]
{
// ... add any modules that your module loads dynamically here ...
}
);
// Include Azure Kinect Sensor and Body Tracking SDKs
string thirdPartyPath = Path.Combine(ModuleDirectory, "../../ThirdParty"); //ModuleDirectory = Project/Plugins/AzureKinectUnreal/Source/AzureKinectUnreal
string azureKinectSensorSDKPath = Path.Combine(thirdPartyPath, "AzureKinectSensor");
string azureKinectBodyTrackingSDKPath = Path.Combine(thirdPartyPath, "AzureKinectBodyTracking");
PublicIncludePaths.AddRange(
new string[]
{
Path.Combine(azureKinectSensorSDKPath, "include"),
Path.Combine(azureKinectBodyTrackingSDKPath, "include")
});
// Libs path
//PublicLibraryPaths.Add(Path.Combine(azureKinectSensorSDKPath, "amd64", "lib"));
//PublicLibraryPaths.Add(Path.Combine(azureKinectBodyTrackingSDKPath, "amd64", "lib"));
PublicAdditionalLibraries.AddRange(
new string[]
{
Path.Combine(azureKinectSensorSDKPath, "amd64", "lib", "k4a.lib"),
Path.Combine(azureKinectBodyTrackingSDKPath, "amd64", "lib", "k4abt.lib")
});
// Ensure that the DLLs are staged along with the executable
RuntimeDependencies.Add("$(PluginDir)/Binaries/Win64/k4a.dll");
RuntimeDependencies.Add("$(PluginDir)/Binaries/Win64/k4abt.dll");
RuntimeDependencies.Add("$(PluginDir)/Binaries/Win64/depthengine_2_0.dll");
}
public Unity(TargetInfo Target)
{
PublicIncludePaths.AddRange(
new string[] {
"Unity/Public"
// ... add public 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",
"AdCollection",
// ... add private dependencies that you statically link with here ...
}
);
DynamicallyLoadedModuleNames.AddRange(
new string[]
{
// ... add any modules that your module loads dynamically here ...
}
);
if (Target.Platform == UnrealTargetPlatform.IOS)
{
PrivateIncludePaths.Add("Private/IOS");
PublicAdditionalFrameworks.Add(
new UEBuildFramework(
"UnityAds", // Framework name
"../ThirdParty/ThirdPartyFrameworks/UnityAds.embeddedframework.zip")
);
PublicAdditionalFrameworks.Add(
new UEBuildFramework(
"AdsUtil", // Framework name
"../ThirdParty/ThirdPartyFrameworks/AdsUtil.embeddedframework.zip")
);
PublicFrameworks.AddRange(
new string[]
{
"EventKit",
"MediaPlayer",
"AdSupport",
"CoreLocation",
"SystemConfiguration",
"MessageUI",
"Security",
"CoreTelephony"
}
);
}
else if (Target.Platform == UnrealTargetPlatform.Android)
{
PrivateIncludePaths.Add("Private/Android");
PrivateDependencyModuleNames.AddRange(
new string[] {
"Launch",
}
);
string PluginPath = Utils.MakePathRelativeTo(ModuleDirectory, BuildConfiguration.RelativeEnginePath);
AdditionalPropertiesForReceipt.Add(new ReceiptProperty("AndroidPlugin", Path.Combine(PluginPath, "Unity_UPL.xml")));
}
else if (Target.Platform == UnrealTargetPlatform.Win32 || Target.Platform == UnrealTargetPlatform.Win64)
{
PrivateIncludePaths.Add("Private/Windows");
}
else if (Target.Platform == UnrealTargetPlatform.Mac)
{
PrivateIncludePaths.Add("Private/Mac");
}
else
{
PrecompileForTargets = PrecompileTargetsType.None;
}
}
public HoudiniEngineEditor(ReadOnlyTargetRules Target) : base(Target)
{
bPrecompile = true;
PCHUsage = PCHUsageMode.UseSharedPCHs;
PrivatePCHHeaderFile = "Private/HoudiniEngineEditorPrivatePCH.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 Editor: Compiling for unsupported platform.");
System.Console.WriteLine(Err);
throw new BuildException(Err);
}
// Find HFS
string HFSPath = GetHFSPath();
HFSPath = HFSPath.Replace("\\", "/");
if (HFSPath != "")
{
PlatformID buildPlatformId = Environment.OSVersion.Platform;
if (buildPlatformId == PlatformID.Win32NT)
{
PublicDefinitions.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[] {
Path.Combine(ModuleDirectory, "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",
"TargetPlatform",
"UnrealEd",
"ApplicationCore",
"CurveEditor",
"Json",
"SceneOutliner"
}
);
DynamicallyLoadedModuleNames.AddRange(
new string[]
{
"PlacementMode",
}
);
}
public UnrealEnginePython(TargetInfo Target)
#endif
{
PCHUsage = ModuleRules.PCHUsageMode.UseExplicitOrSharedPCHs;
string enableUnityBuild = System.Environment.GetEnvironmentVariable("UEP_ENABLE_UNITY_BUILD");
bFasterWithoutUnity = string.IsNullOrEmpty(enableUnityBuild);
PublicIncludePaths.AddRange(
new string[] {
"UnrealEnginePython/Public",
// ... add public include paths required here ...
}
);
PrivateIncludePaths.AddRange(
new string[] {
"UnrealEnginePython/Private",
// ... add other private include paths required here ...
}
);
PublicDependencyModuleNames.AddRange(
new string[]
{
"Core",
"Sockets",
"Networking"
// ... add other public dependencies that you statically link with here ...
}
);
PrivateDependencyModuleNames.AddRange(
new string[]
{
"CoreUObject",
"Engine",
"InputCore",
"Slate",
"SlateCore",
"MovieScene",
"LevelSequence",
"HTTP",
"UMG",
"AppFramework",
"RHI",
"Voice",
"RenderCore",
"MovieSceneCapture",
"Landscape",
"Foliage",
// ... add private dependencies that you statically link with here ...
}
);
#if WITH_FORWARDED_MODULE_RULES_CTOR
BuildVersion Version;
if (BuildVersion.TryRead(BuildVersion.GetDefaultFileName(), out Version))
{
if (Version.MinorVersion >= 18)
{
PrivateDependencyModuleNames.Add("ApplicationCore");
}
}
#endif
DynamicallyLoadedModuleNames.AddRange(
new string[]
{
// ... add any modules that your module loads dynamically here ...
}
);
#if WITH_FORWARDED_MODULE_RULES_CTOR
if (Target.bBuildEditor)
#else
if (UEBuildConfiguration.bBuildEditor)
#endif
{
PrivateDependencyModuleNames.AddRange(new string[] {
"UnrealEd",
"LevelEditor",
"BlueprintGraph",
"Projects",
"Sequencer",
"SequencerWidgets",
"AssetTools",
"LevelSequenceEditor",
"MovieSceneTools",
"MovieSceneTracks",
"CinematicCamera",
"EditorStyle",
"GraphEditor",
"UMGEditor",
"AIGraph",
"RawMesh",
"DesktopWidgets",
"EditorWidgets",
"FBX",
"Persona",
"PropertyEditor",
"LandscapeEditor",
"MaterialEditor"
});
}
if ((Target.Platform == UnrealTargetPlatform.Win64) || (Target.Platform == UnrealTargetPlatform.Win32))
{
if (pythonHome == "")
{
pythonHome = DiscoverPythonPath(windowsKnownPaths);
if (pythonHome == "")
{
throw new System.Exception("Unable to find Python installation");
}
}
System.Console.WriteLine("Using Python at: " + pythonHome);
PublicIncludePaths.Add(pythonHome);
string libPath = GetWindowsPythonLibFile(pythonHome);
PublicLibraryPaths.Add(Path.GetDirectoryName(libPath));
PublicAdditionalLibraries.Add(libPath);
}
else if (Target.Platform == UnrealTargetPlatform.Mac)
{
if (pythonHome == "")
{
pythonHome = DiscoverPythonPath(macKnownPaths);
if (pythonHome == "")
{
throw new System.Exception("Unable to find Python installation");
}
}
System.Console.WriteLine("Using Python at: " + pythonHome);
PublicIncludePaths.Add(pythonHome);
string libPath = GetMacPythonLibFile(pythonHome);
PublicLibraryPaths.Add(Path.GetDirectoryName(libPath));
PublicDelayLoadDLLs.Add(libPath);
Definitions.Add(string.Format("UNREAL_ENGINE_PYTHON_ON_MAC"));
}
else if (Target.Platform == UnrealTargetPlatform.Linux)
{
if (pythonHome == "")
{
string includesPath = DiscoverLinuxPythonIncludesPath();
if (includesPath == null)
{
throw new System.Exception("Unable to find Python includes, please add a search path to linuxKnownIncludesPaths");
}
string libsPath = DiscoverLinuxPythonLibsPath();
if (libsPath == null)
{
throw new System.Exception("Unable to find Python libs, please add a search path to linuxKnownLibsPaths");
}
PublicIncludePaths.Add(includesPath);
PublicAdditionalLibraries.Add(libsPath);
}
else
{
string[] items = pythonHome.Split(';');
PublicIncludePaths.Add(items[0]);
PublicAdditionalLibraries.Add(items[1]);
}
Definitions.Add(string.Format("UNREAL_ENGINE_PYTHON_ON_LINUX"));
}
}
public GaoShiPlugin(ReadOnlyTargetRules Target) : base(Target)
{
//Type = ModuleType.External;
PCHUsage = ModuleRules.PCHUsageMode.UseExplicitOrSharedPCHs;
//PCHUsage = ModuleRules.PCHUsageMode.Default;
//PrecompileForTargets = ModuleRules.PrecompileTargetsType.Any;
if (Target.Type == TargetType.Editor)
{
PublicDependencyModuleNames.AddRange(
new string[] { "UnrealED" });
PublicIncludePaths.AddRange(
new string[] {
"UnrealED/Public"
}
);
}
PublicIncludePaths.AddRange(
new string[] {
"GaoShiPlugin/Public",
"Foliage/Public",
"Engine",
ThirdPartProject,
// ... add public include paths required here ...
}
);
PrivateIncludePaths.AddRange(
new string[] {
"GaoShiPlugin/Private",
"Foliage/Private",
"Foliage/Public",
"Engine",
//"Engine/Class/Engine",
"Engine",
ThirdPartProject,
// ... add other private include paths required here ...
}
);
PublicDependencyModuleNames.AddRange(
new string[]
{
"Core",
"Foliage",
"ApplicationCore",
"ContentBrowser",
"Engine"
// ... add other public dependencies that you statically link with here ...
}
);
PrivateDependencyModuleNames.AddRange(
new string[]
{
"CoreUObject",
"Engine",
"Slate",
"SlateCore",
// ... add private dependencies that you statically link with here ...
}
);
string ThirdPartPath = ThirdPartProject;
if (Target.Platform == UnrealTargetPlatform.Win32)
{
ThirdPartPath += "win32\\";
}
else if (Target.Platform == UnrealTargetPlatform.Win64)
{
ThirdPartPath += "win64\\";
}
PublicAdditionalLibraries.AddRange(
new string[]
{
ThirdPartPath + "POExportCpp14Interface.lib"
}
);
DynamicallyLoadedModuleNames.AddRange(
new string[]
{
// ... add any modules that your module loads dynamically here ...
}
);
}
public libOpus(ReadOnlyTargetRules Target) : base(Target)
{
/** Mark the current version of the library */
string OpusVersion = "1.1";
Type = ModuleType.External;
PublicIncludePaths.Add(Target.UEThirdPartySourceDirectory + "libOpus/opus-" + OpusVersion + "/include");
string LibraryPath = Target.UEThirdPartySourceDirectory + "libOpus/opus-" + OpusVersion + "/";
if ((Target.Platform == UnrealTargetPlatform.Win64) ||
(Target.Platform == UnrealTargetPlatform.Win32))
{
LibraryPath += "Windows/VS2012/";
if (Target.Platform == UnrealTargetPlatform.Win64)
{
LibraryPath += "x64/";
}
else
{
LibraryPath += "win32/";
}
LibraryPath += "Release/";
PublicLibraryPaths.Add(LibraryPath);
PublicAdditionalLibraries.Add("silk_common.lib");
PublicAdditionalLibraries.Add("silk_float.lib");
PublicAdditionalLibraries.Add("celt.lib");
PublicAdditionalLibraries.Add("opus.lib");
PublicAdditionalLibraries.Add("speex_resampler.lib");
}
else if (Target.Platform == UnrealTargetPlatform.Mac)
{
string OpusPath = LibraryPath + "/Mac/libopus.a";
string SpeexPath = LibraryPath + "/Mac/libspeex_resampler.a";
PublicAdditionalLibraries.Add(OpusPath);
PublicAdditionalLibraries.Add(SpeexPath);
}
else if (Target.Platform == UnrealTargetPlatform.Linux)
{
if (Target.LinkType == TargetLinkType.Monolithic)
{
PublicAdditionalLibraries.Add(LibraryPath + "Linux/" + Target.Architecture + "/libopus.a");
}
else
{
PublicAdditionalLibraries.Add(LibraryPath + "Linux/" + Target.Architecture + "/libopus_fPIC.a");
}
if (Target.Architecture.StartsWith("x86_64"))
{
if (Target.LinkType == TargetLinkType.Monolithic)
{
PublicAdditionalLibraries.Add(LibraryPath + "Linux/" + Target.Architecture + "/libresampler.a");
}
else
{
PublicAdditionalLibraries.Add(LibraryPath + "Linux/" + Target.Architecture + "/libresampler_fPIC.a");
}
}
}
else if (Target.Platform == UnrealTargetPlatform.Android)
{
PublicLibraryPaths.Add(LibraryPath + "Android/ARMv7/");
PublicLibraryPaths.Add(LibraryPath + "Android/ARM64/");
PublicLibraryPaths.Add(LibraryPath + "Android/x64/");
PublicAdditionalLibraries.Add("opus");
PublicAdditionalLibraries.Add("speex_resampler");
}
else if (Target.Platform == UnrealTargetPlatform.XboxOne)
{
LibraryPath += "XboxOne/VS2015/Release/";
PublicLibraryPaths.Add(LibraryPath);
PublicAdditionalLibraries.Add("silk_common.lib");
PublicAdditionalLibraries.Add("silk_float.lib");
PublicAdditionalLibraries.Add("celt.lib");
PublicAdditionalLibraries.Add("opus.lib");
PublicAdditionalLibraries.Add("speex_resampler.lib");
}
}
//Determines if we have precomputed dependency data for the specified target and Engine version, and processes it if we do
private bool ProcessPrecomputedData(ReadOnlyTargetRules target, string engineVersion, string stagingDir)
{
//Resolve the paths to the files and directories that will exist if we have precomputed data for the target
string targetDir = Path.Combine(ModuleDirectory, "precomputed", engineVersion, this.TargetIdentifier(target));
string flagsFile = Path.Combine(targetDir, "flags.json");
string includeDir = Path.Combine(targetDir, "include");
string libDir = Path.Combine(targetDir, "lib");
string binDir = Path.Combine(targetDir, "bin");
string dataDir = Path.Combine(targetDir, "data");
//If any of the required files or directories do not exist then we do not have precomputed data
if (!File.Exists(flagsFile) || !Directory.Exists(includeDir) || !Directory.Exists(libDir) || !Directory.Exists(binDir) || !Directory.Exists(dataDir))
{
return(false);
}
//Add the precomputed include directory to our search paths
PublicIncludePaths.Add(includeDir);
//Link against all static library files (and import libraries for DLLs under Windows) in the lib directory
string libExtension = ((this.IsWindows(target)) ? ".lib" : ".a");
string[] libs = Directory.GetFiles(libDir, "*" + libExtension);
foreach (string lib in libs)
{
PublicAdditionalLibraries.Add(lib);
}
//Under non-Windows platforms, link against all shared library files in the lib directory
if (this.IsWindows(target) == false)
{
List <string> sharedLibs = new List <string>();
sharedLibs.AddRange(Directory.GetFiles(libDir, "*.dylib"));
sharedLibs.AddRange(Directory.GetFiles(libDir, "*.so"));
foreach (string lib in sharedLibs)
{
PublicAdditionalLibraries.Add(lib);
}
}
//Ensure any shared libraries are staged alongside the binaries for the plugin
string[] searchDirs = new string[] { binDir, libDir };
foreach (string dir in searchDirs)
{
List <string> binaries = new List <string>();
binaries.AddRange(Directory.GetFiles(dir, "*.dll"));
binaries.AddRange(Directory.GetFiles(dir, "*.dylib"));
binaries.AddRange(Directory.GetFiles(dir, "*.so"));
foreach (string binary in binaries)
{
RuntimeDependencies.Add(Path.Combine("$(BinaryOutputDir)", Path.GetFileName(binary)), binary, StagedFileType.NonUFS);
}
}
//Attempt to parse the JSON file containing any additional flags, modules and system libraries
JsonObject flags = JsonObject.Read(new FileReference(flagsFile));
//Link against any Unreal Engine modules for bundled third-party libraries
PrivateDependencyModuleNames.AddRange(flags.GetStringArrayField("unreal_modules"));
//Add any preprocessor definitions specified by the JSON file
PublicDefinitions.AddRange(flags.GetStringArrayField("defines"));
//Link against any system libraries specified by the JSON file, ensuring we add the file extension under Windows
string[] systemLibs = flags.GetStringArrayField("system_libs");
foreach (string lib in systemLibs)
{
string libFull = lib + ((this.IsWindows(target)) ? libExtension : "");
PublicAdditionalLibraries.Add(libFull);
}
//Copy any data files needed by the package into our staging directory
string[] files = Directory.GetFiles(dataDir, "*", SearchOption.AllDirectories);
foreach (string file in files)
{
RuntimeDependencies.Add(Path.Combine(stagingDir, Path.GetFileName(file)), file, StagedFileType.NonUFS);
}
return(true);
}
public Noesis(ReadOnlyTargetRules Target) : base(Target)
{
Type = ModuleType.External;
string NoesisBasePath = ModuleDirectory + "/NoesisSDK/";
string NoesisIncludePath = NoesisBasePath + "Include/";
string NoesisInteractivityIncludePath = NoesisBasePath + "Src/Packages/App/Interactivity/Include/";
PublicIncludePaths.Add(ModuleDirectory);
PublicIncludePaths.Add(NoesisIncludePath);
PublicIncludePaths.Add(NoesisInteractivityIncludePath);
// Let's try to make sure the right version of the SDK is in the right place.
const string RequiredRevision = "(r7995)";
const string RequiredVersionName = "2.2.1";
PublicDefinitions.Add("NOESIS_VERSION_NAME=\"" + RequiredVersionName + "\"");
if (!Directory.Exists(NoesisBasePath))
{
throw new BuildException("Could not find NoesisGUI SDK in " + NoesisBasePath + ". Minimum required version is " + RequiredVersionName);
}
if (!Directory.Exists(NoesisBasePath + "Bin"))
{
throw new BuildException("Could not find NoesisGUI SDK Bin directory in " + NoesisBasePath + "Bin. Minimum required version is " + RequiredVersionName);
}
if (!Directory.Exists(NoesisBasePath + "Include"))
{
throw new BuildException("Could not find NoesisGUI SDK Include directory in " + NoesisBasePath + "Include. Minimum required version is " + RequiredVersionName);
}
if (!Directory.Exists(NoesisBasePath + "Lib"))
{
throw new BuildException("Could not find NoesisGUI SDK Lib directory in " + NoesisBasePath + "Lib. Minimum required version is " + RequiredVersionName);
}
string NoesisSdkVersionInfo;
try
{
NoesisSdkVersionInfo = File.ReadAllText(NoesisBasePath + "version.txt");
}
catch (Exception)
{
throw new BuildException("Could not find NoesisGUI SDK version.txt in " + NoesisBasePath + "version.txt. Minimum required version is " + RequiredVersionName);
}
string[] SplitVersion = NoesisSdkVersionInfo.Split(' ');
if (String.Compare(SplitVersion[SplitVersion.Length - 1], RequiredRevision) < 0)
{
throw new BuildException("Wrong version of the NoesisGUI SDK installed in " + NoesisBasePath + ". Minimum required version is " + RequiredVersionName);
}
PublicSystemIncludePaths.Add(NoesisIncludePath);
if (Target.Platform == UnrealTargetPlatform.Win64)
{
string NoesisLibPath = NoesisBasePath + "Lib/windows_x86_64/";
PublicLibraryPaths.Add(NoesisLibPath);
PublicAdditionalLibraries.Add("Noesis.lib");
string NoesisDllPath = "/NoesisSDK/Bin/windows_x86_64/Noesis.dll";
string NoesisDllTargetPath = "/Binaries/Win64/Noesis.dll";
if (Target.ProjectFile != null)
{
CopyNoesisDll(ModuleDirectory + NoesisDllPath, DirectoryReference.FromFile(Target.ProjectFile).ToString() + NoesisDllTargetPath);
}
CopyNoesisDll(ModuleDirectory + NoesisDllPath, ModuleDirectory + "/../.." + NoesisDllTargetPath);
if (System.IO.File.Exists(Target.RelativeEnginePath + NoesisDllTargetPath))
{
System.IO.File.Delete(Target.RelativeEnginePath + NoesisDllTargetPath);
}
if (Target.LinkType == TargetLinkType.Monolithic)
{
RuntimeDependencies.Add("$(ProjectDir)" + NoesisDllTargetPath);
}
else
{
RuntimeDependencies.Add("$(EngineDir)" + NoesisDllTargetPath);
}
}
else if (Target.Platform == UnrealTargetPlatform.Mac)
{
string NoesisLibPath = NoesisBasePath + "Bin/osx/";
PublicLibraryPaths.Add(NoesisLibPath);
PublicAdditionalLibraries.Add(NoesisLibPath + "Noesis.dylib");
string NoesisDylibPath = "/NoesisSDK/Bin/osx/Noesis.dylib";
RuntimeDependencies.Add(ModuleDirectory + NoesisDylibPath);
}
else if (Target.Platform == UnrealTargetPlatform.IOS)
{
string NoesisLibPath = NoesisBasePath + "Lib/ios/";
PublicLibraryPaths.Add(NoesisLibPath);
PublicAdditionalLibraries.Add("Noesis");
}
else if (Target.Platform == UnrealTargetPlatform.Android)
{
string NoesisLibPath = NoesisBasePath + "Bin/android_arm/";
PublicLibraryPaths.Add(NoesisLibPath);
string NoesisLib64Path = NoesisBasePath + "Bin/android_arm64/";
PublicLibraryPaths.Add(NoesisLib64Path);
PublicAdditionalLibraries.Add("Noesis");
string NoesisAplPath = "/Noesis_APL.xml";
AdditionalPropertiesForReceipt.Add("AndroidPlugin", ModuleDirectory + NoesisAplPath);
}
else if (Target.Platform == UnrealTargetPlatform.PS4)
{
string NoesisLibPath = NoesisBasePath + "Lib/ps4/";
PublicAdditionalLibraries.Add(NoesisLibPath + "Noesis.a");
}
else if (Target.Platform == UnrealTargetPlatform.XboxOne)
{
string NoesisLibPath = NoesisBasePath + "Bin/xbox_one/";
PublicLibraryPaths.Add(NoesisLibPath);
PublicAdditionalLibraries.Add("Noesis.lib");
}
else if (Target.Platform == UnrealTargetPlatform.HTML5)
{
string NoesisLibPath = NoesisBasePath + "Bin/wasm/";
PublicAdditionalLibraries.Add(NoesisLibPath + "Noesis.bc");
}
}
public Vivox(ReadOnlyTargetRules Target) : base(Target)
{
PublicIncludePaths.AddRange(
new string[] {
string.Format("{0}/Public", ModuleDirectory),
}
);
PrivateIncludePaths.AddRange(
new string[] {
string.Format("{0}/Private", ModuleDirectory),
}
);
PublicDependencyModuleNames.AddRange(
new string[] {
"Core",
"CoreUObject",
"VivoxCoreLibrary",
"Projects",
"Engine",
"VivoxCore"
}
);
PrivateDependencyModuleNames.AddRange(
new string[] {
// ... add private dependencies that you statically link with here ...
"VivoxCore"
}
);
DynamicallyLoadedModuleNames.AddRange(
new string[]
{
}
);
if (Target.Type != TargetRules.TargetType.Server)
{
if (Target.Platform == UnrealTargetPlatform.Win64)
{
PublicDefinitions.Add("WITH_VIVOX=1");
}
else if (Target.Platform == UnrealTargetPlatform.Mac)
{
PublicDefinitions.Add("WITH_VIVOX=1");
}
else if (Target.Platform == UnrealTargetPlatform.Android)
{
PublicDefinitions.Add("WITH_VIVOX=1");
}
else if (Target.Platform == UnrealTargetPlatform.IOS)
{
PublicDefinitions.Add("WITH_VIVOX=1");
}
else
{
PublicDefinitions.Add("WITH_VIVOX=0");
}
}
else
{
PublicDefinitions.Add("WITH_VIVOX=0");
}
// Build
PCHUsage = ModuleRules.PCHUsageMode.UseExplicitOrSharedPCHs;
}
public NetworkingTemplatePlugin(ReadOnlyTargetRules Target) : base(Target)
{
PCHUsage = ModuleRules.PCHUsageMode.UseExplicitOrSharedPCHs;
bEnableExceptions = true;
PublicIncludePaths.AddRange(
new string[]
{
//"NetworkingTemplatePlugin" ,
//"NetworkingTemplatePlugin/Public" ,
//"NetworkingTemplatePlugin/Public/Actors" ,
//"NetworkingTemplatePlugin/Public/Actors/Pawns" ,
//"NetworkingTemplatePlugin/Public/Actors/Pawns/Characters" ,
//"NetworkingTemplatePlugin/Public/Framework" ,
//"NetworkingTemplatePlugin/Public/Networking" ,
//"NetworkingTemplatePlugin/Public/Networking/NetSlime" ,
//"NetworkingTemplatePlugin/Public/UserInterface" ,
//"NetworkingTemplatePlugin/Public/Utilities" ,
//"NetworkingTemplatePlugin/Public/Utilities/Bitmask" ,
// ... add public include paths required here ...
}
);
PrivateIncludePaths.AddRange(
new string[]
{
// ... add other private include paths required here ...
}
);
PublicDependencyModuleNames.AddRange(
new string[]
{
"Core",
"CoreUObject",
"Engine",
"HeadMountedDisplay",
"InputCore",
"Slate",
"SlateCore",
"UMG",
// ... add other public dependencies that you statically link with here ...
// Added
"AdvancedSessions",
"AdvancedSteamSessions",
"NetSlime",
"StaticUtils",
// Networking
"Networking",
"OnlineSubsystem",
"OnlineSubsystemNull",
"OnlineSubsystemUtils",
"Sockets",
"Steamworks"
}
);
PrivateDependencyModuleNames.AddRange(
new string[]
{
"CoreUObject",
"Engine",
"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 GameAnalytics(TargetInfo Target)
#endif
{
PCHUsage = PCHUsageMode.UseExplicitOrSharedPCHs;
var GameAnalyticsPath = Path.GetFullPath(Path.Combine(ModuleDirectory, "../ThirdParty/"));
var libPath = Path.Combine(GameAnalyticsPath, "lib");
if (Target.Platform == UnrealTargetPlatform.Win64)
{
PublicAdditionalLibraries.Add(Path.Combine(libPath, "win64", "GameAnalytics.lib"));
PrivateDependencyModuleNames.AddRange(new string[] { "OpenSSL", "libcurl" });
}
else if (Target.Platform == UnrealTargetPlatform.Win32)
{
PublicAdditionalLibraries.Add(Path.Combine(libPath, "win32", "GameAnalytics.lib"));
PrivateDependencyModuleNames.AddRange(new string[] { "OpenSSL", "libcurl" });
}
else if (Target.Platform == UnrealTargetPlatform.Android)
{
PrivateDependencyModuleNames.Add("Launch");
PrivateIncludePaths.Add(Path.Combine(ModuleDirectory, "Private/Android"));
}
else if (Target.Platform == UnrealTargetPlatform.Mac)
{
PublicAdditionalLibraries.Add(Path.Combine(libPath, "osx", "libGameAnalytics.a"));
PublicAdditionalLibraries.Add("curl");
PublicFrameworks.AddRange(
new string[] {
"CoreFoundation",
"Foundation",
"CoreServices"
}
);
PrivateDependencyModuleNames.AddRange(new string[] { "OpenSSL" });
}
else if (Target.Platform == UnrealTargetPlatform.Linux)
{
PublicAdditionalLibraries.Add(Path.Combine(libPath, "linux", "libGameAnalytics.a"));
PrivateDependencyModuleNames.AddRange(new string[] { "OpenSSL", "libcurl" });
}
else if (Target.Platform == UnrealTargetPlatform.IOS)
{
PublicAdditionalLibraries.Add(Path.Combine(libPath, "ios", "libGameAnalytics.a"));
PrivateIncludePaths.Add(Path.Combine(ModuleDirectory, "Private/IOS"));
PublicFrameworks.AddRange(
new string[] {
"AdSupport",
"SystemConfiguration"
}
);
PublicAdditionalLibraries.AddRange(
new string[] {
"sqlite3",
"z",
"c++"
});
}
else if (Target.Platform == UnrealTargetPlatform.HTML5)
{
if (Target.Architecture != "-win32")
{
PublicAdditionalLibraries.Add(Path.Combine(libPath, "html5", "GameAnalytics.jspre"));
PublicAdditionalLibraries.Add(Path.Combine(libPath, "html5", "GameAnalyticsUnreal.js"));
}
}
else
{
throw new NotImplementedException("This target platform is not configured for GameAnalytics SDK: " + Target.Platform.ToString());
}
PublicDependencyModuleNames.AddRange(
new string[]
{
"Core",
"CoreUObject",
"Engine",
// ... add other public dependencies that you statically link with here ...
}
);
PrivateIncludePaths.Add(Path.GetFullPath(Path.Combine(ModuleDirectory, "Private")));
PrivateIncludePaths.Add(Path.GetFullPath(Path.Combine(ModuleDirectory, "Public")));
PublicIncludePaths.Add(Path.GetFullPath(Path.Combine(ModuleDirectory, "Public")));
PrivateDependencyModuleNames.AddRange(
new string[]
{
"Analytics",
"Engine"
}
);
if (Target.Platform == UnrealTargetPlatform.HTML5)
{
PrivateDependencyModuleNames.AddRange(
new string[]
{
"Json"
}
);
PublicIncludePathModuleNames.AddRange(
new string[]
{
"Json"
}
);
}
PublicIncludePathModuleNames.AddRange(
new string[]
{
"Analytics",
"Engine"
}
);
if (Target.Platform == UnrealTargetPlatform.Android)
{
string PluginPath = Utils.MakePathRelativeTo(ModuleDirectory, Target.RelativeEnginePath);
AdditionalPropertiesForReceipt.Add("AndroidPlugin", Path.Combine(PluginPath, "GameAnalytics_APL.xml"));
}
}
public Sharing(TargetInfo Target)
{
PublicIncludePaths.AddRange(
new string[] {
// ... add public include paths required here ...
}
);
PrivateIncludePaths.AddRange(
new string[] {
"Developer/Sharing/Private",
// ... add other private include paths required here ...
}
);
PublicDependencyModuleNames.AddRange(
new string[]
{
"Core",
"CoreUObject",
"Engine"
// ... add other public dependencies that you statically link with here ...
}
);
PrivateDependencyModuleNames.AddRange(
new string[]
{
//"CoreUObject",
//"Engine",
//"InputCore",
//"RHI",
//"RenderCore",
//"HTTP",
//"UMG", "Slate", "SlateCore",
//"ImageWrapper",
// ... 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",
"Launch",
}
);
if (Target.Platform == UnrealTargetPlatform.IOS)
{
PublicFrameworks.AddRange(
new string[]
{
}
);
}
else if (Target.Platform == UnrealTargetPlatform.Android)
{
string PluginPath = Utils.MakePathRelativeTo(ModuleDirectory, BuildConfiguration.RelativeEnginePath);
AdditionalPropertiesForReceipt.Add(new ReceiptProperty("AndroidPlugin", Path.Combine(PluginPath, "Sharing_APL.xml")));
}
}
public HoudiniEngineEditor(TargetInfo Target)
{
bool bIsRelease = true;
string HFSPath = "";
string HoudiniVersion = "15.0.413";
// 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",
"DesktopWidgets",
"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 HoudiniEngineEditor(ReadOnlyTargetRules Target) : base(Target)
{
PCHUsage = PCHUsageMode.UseSharedPCHs;
bool bIsRelease = true;
string HFSPath = "";
string HoudiniVersion = "16.5.530";
// 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);
}
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 = "/Applications/Houdini/Houdini" + HoudiniVersion + "/Frameworks/Houdini.framework/Versions/Current/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;
}
}
else
{
HFSPath = System.Environment.GetEnvironmentVariable("HFS");
System.Console.WriteLine("Linux - found HFS:" + HFSPath);
}
}
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);
// Add the custom include path as well in case the toolkit path doesn't exist yet.
PublicIncludePaths.Add(HFSPath + "/custom/houdini/include/HAPI");
}
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 AppleARKit(ReadOnlyTargetRules Target) : base(Target)
{
PublicIncludePaths.AddRange(
new string[] {
"AppleARKit/Public"
// ... add public include paths required here ...
}
);
PrivateIncludePaths.AddRange(
new string[] {
"AppleARKit/Private",
"../../../../Source/Runtime/Renderer/Private",
// ... add other private include paths required here ...
}
);
PublicDependencyModuleNames.AddRange(
new string[]
{
"Core",
"Engine",
// ... add other public dependencies that you statically link with here ...
}
);
PrivateDependencyModuleNames.AddRange(
new string[]
{
"CoreUObject",
"Slate",
"SlateCore",
"RHI",
"Renderer",
"RenderCore",
"ShaderCore",
"HeadMountedDisplay",
"IOSRuntimeSettings",
"AugmentedReality",
// "ProceduralMeshComponent",
// "LiveLink",
// "LiveLinkInterface",
// "OnlineSubsystem",
"Sockets"
// ... add private dependencies that you statically link with here ...
}
);
DynamicallyLoadedModuleNames.AddRange(
new string[]
{
// ... add any modules that your module loads dynamically here ...
}
);
if (Target.Platform == UnrealTargetPlatform.IOS)
{
PublicDefinitions.Add("ARKIT_SUPPORT=1");
PublicFrameworks.Add("ARKit");
}
else
{
PublicDefinitions.Add("ARKIT_SUPPORT=0");
}
}
public RuntimeMeshLoader(ReadOnlyTargetRules Target) : base(Target)
{
PCHUsage = ModuleRules.PCHUsageMode.UseExplicitOrSharedPCHs;
PublicIncludePaths.AddRange(
new string[] {
"RuntimeMeshLoader/Public",
Path.Combine(ThirdPartyPath, "assimp/include")
// ... add public include paths required here ...
}
);
PrivateIncludePaths.AddRange(
new string[] {
"RuntimeMeshLoader/Private",
// ... add other private include paths required here ...
}
);
PublicDependencyModuleNames.AddRange(
new string[]
{
"Core",
"CoreUObject",
"Engine",
"RHI",
"RenderCore",
"ProceduralMeshComponent"
// ... add other public dependencies that you statically link with here ...
}
);
PrivateDependencyModuleNames.AddRange(
new string[]
{
"Slate",
"SlateCore",
// ... add private dependencies that you statically link with here ...
}
);
DynamicallyLoadedModuleNames.AddRange(
new string[]
{
}
);
if ((Target.Platform == UnrealTargetPlatform.Win64) || (Target.Platform == UnrealTargetPlatform.Win32))
{
string PlatformString = (Target.Platform == UnrealTargetPlatform.Win64) ? "Win64" : "Win32";
PublicAdditionalLibraries.Add(Path.Combine(ThirdPartyPath, "assimp/lib", PlatformString, "assimp-vc140-mt.lib"));
RuntimeDependencies.Add(new RuntimeDependency(Path.Combine(ThirdPartyPath, "assimp/bin", PlatformString, "assimp-vc140-mt.dll")));
}
else if (Target.Platform == UnrealTargetPlatform.Mac)
{
string PlatformString = "Mac";
PublicAdditionalLibraries.Add(Path.Combine(ThirdPartyPath, "assimp/lib", PlatformString, "libassimp.4.1.0.dylib"));
}
else if (Target.Platform == UnrealTargetPlatform.Linux)
{
string PlatformString = "Linux";
PublicAdditionalLibraries.Add(Path.Combine(ThirdPartyPath, "assimp/lib", PlatformString, "libassimp.so"));
RuntimeDependencies.Add(new RuntimeDependency(Path.Combine(ThirdPartyPath, "assimp/lib", PlatformString, "libassimp.so")));
RuntimeDependencies.Add(new RuntimeDependency(Path.Combine(ThirdPartyPath, "assimp/lib", PlatformString, "libassimp.so.4")));
RuntimeDependencies.Add(new RuntimeDependency(Path.Combine(ThirdPartyPath, "assimp/lib", PlatformString, "libassimp.so.4.1.0")));
}
}
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.IsInPlatformGroup(UnrealPlatformGroup.Windows)))
{
AddEngineThirdPartyPrivateStaticDependencies(Target,
"XInput"
);
if (Target.bCompileWithAccessibilitySupport && !Target.bIsBuildingConsoleApplication)
{
PublicSystemLibraries.Add("uiautomationcore.lib");
}
}
else if (Target.Platform == UnrealTargetPlatform.Mac)
{
AddEngineThirdPartyPrivateStaticDependencies(Target,
"OpenGL"
);
if (Target.bBuildEditor == true)
{
string SDKROOT = Utils.RunLocalProcessAndReturnStdOut("/usr/bin/xcrun", "--sdk macosx --show-sdk-path");
PublicAdditionalLibraries.Add(SDKROOT + "/System/Library/PrivateFrameworks/MultitouchSupport.framework/Versions/Current/MultitouchSupport.tbd");
}
}
else if (Target.IsInPlatformGroup(UnrealPlatformGroup.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.IOS || Target.Platform == UnrealTargetPlatform.TVOS)
{
PublicIncludePaths.AddRange(new string[] { "Runtime/ApplicationCore/Public/IOS" });
AddEngineThirdPartyPrivateStaticDependencies(Target, "SoundSwitch");
// export ApplicationCore symbols for embedded Dlls
ModuleSymbolVisibility = ModuleRules.SymbolVisibility.VisibileForDll;
//Need to add this as BackgroundHTTP files can end up doing work directly from our AppDelegate in iOS and thus we need acccess to correct file locations to save these very early.
PrivateDependencyModuleNames.Add("BackgroundHTTPFileHash");
}
else if (Target.Platform == UnrealTargetPlatform.Android || Target.Platform == UnrealTargetPlatform.Lumin)
{
PrivateIncludePathModuleNames.AddRange(
new string[] {
"Launch"
}
);
}
if (!Target.bCompileAgainstApplicationCore)
{
throw new System.Exception("ApplicationCore cannot be used when Target.bCompileAgainstApplicationCore = false.");
}
}
public EOD(ReadOnlyTargetRules Target) : base(Target)
{
PCHUsage = PCHUsageMode.UseExplicitOrSharedPCHs;
PublicIncludePaths.AddRange(
new string[] {
"EOD/Public/AI",
"EOD/Public/AI/Components",
"EOD/Public/AnimInstances",
"EOD/Public/Characters",
"EOD/Public/Characters/Components",
"EOD/Public/Characters/States",
"EOD/Public/Core",
"EOD/Public/Gameplay",
"EOD/Public/Gameplay/Abilities",
"EOD/Public/Gameplay/AbilityTasks",
"EOD/Public/Gameplay/Attributes",
"EOD/Public/Gameplay/Calculations",
"EOD/Public/Gameplay/Skills",
"EOD/Public/Gameplay/Effects",
"EOD/Public/Gameplay/Events",
"EOD/Public/Interfaces",
"EOD/Public/Notifies",
"EOD/Public/Player",
"EOD/Public/Player/Components",
"EOD/Public/SaveSystem",
"EOD/Public/Statics",
"EOD/Public/UI",
"EOD/Public/UI/Menu",
"EOD/Public/Weapons",
"EOD/Public/Interactives",
"EOD/Public/Lootables",
"EOD/Public/Items",
"EOD/Public/Widgets",
"EOD/Public/UI_DEPRECATED"
}
);
PrivateIncludePaths.AddRange(
new string[] {
}
);
PublicDependencyModuleNames.AddRange(
new string[] {
"Core",
"CoreUObject",
"Engine",
"InputCore",
"UMG",
"AssetRegistry",
"AIModule",
"XmlParser",
"Json",
"MoviePlayer",
"RHI",
"LevelSequence",
"PhysicsCore"
}
);
PublicDependencyModuleNames.AddRange(
new string[] {
"GameplayAbilities",
"GameplayTags",
"GameplayTasks",
}
);
PrivateDependencyModuleNames.AddRange(new string[] { });
// Uncomment if you are using Slate UI
PrivateDependencyModuleNames.AddRange(new string[] { "Slate", "SlateCore" });
// Uncomment if you are using online features
PrivateDependencyModuleNames.AddRange(new string[] { "OnlineSubsystem", "OnlineSubsystemNull", "OnlineSubsystemSteam" });
// To include OnlineSubsystemSteam, add it to the plugins section in your uproject file with the Enabled attribute set to true
}
public UnrealFrontend(ReadOnlyTargetRules Target) : base(Target)
{
PublicIncludePaths.AddRange(
new string[] {
"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 GalaxySDK(ReadOnlyTargetRules Target) : base(Target)
{
Type = ModuleType.External;
if (!Directory.Exists(ModuleDirectory))
{
string Err = string.Format("GalaxySDK not found in {0}", ModuleDirectory);
System.Console.WriteLine(Err);
throw new BuildException(Err);
}
if (!Directory.Exists(IncludePath))
{
string Err = string.Format("Galaxy 'Include' folder not found: {0}", IncludePath);
System.Console.WriteLine(Err);
throw new BuildException(Err);
}
PublicIncludePaths.Add(IncludePath);
if (!Directory.Exists(LibrariesPath))
{
string Err = string.Format(" Galaxy'Libraries' folder not found: {0}", LibrariesPath);
System.Console.WriteLine(Err);
throw new BuildException(Err);
}
PublicLibraryPaths.Add(LibrariesPath);
string galaxyDLLName;
if (Target.Platform == UnrealTargetPlatform.Win32)
{
galaxyDLLName = "Galaxy.dll";
PublicDelayLoadDLLs.Add(galaxyDLLName);
PublicAdditionalLibraries.Add("Galaxy.lib");
}
else if (Target.Platform == UnrealTargetPlatform.Win64)
{
galaxyDLLName = "Galaxy64.dll";
PublicDelayLoadDLLs.Add(galaxyDLLName);
PublicAdditionalLibraries.Add("Galaxy64.lib");
}
else if (Target.Platform == UnrealTargetPlatform.Mac)
{
galaxyDLLName = "libGalaxy.dylib";
string galaxyDLLPath = Path.Combine(LibrariesPath, galaxyDLLName);
PublicDelayLoadDLLs.Add(galaxyDLLPath);
#if !UE_4_22_OR_LATER
PublicAdditionalShadowFiles.Add(galaxyDLLPath);
AdditionalBundleResources.Add(new UEBuildBundleResource(galaxyDLLPath, "MacOS"));
#endif
}
else if (Target.Platform == UnrealTargetPlatform.XboxOne)
{
galaxyDLLName = "Galaxy64_Durango.dll";
PublicAdditionalLibraries.Add("Galaxy64_Durango.lib");
// In order to compile this for XBOX, please copy 'delayimp.lib' binary from:
// from: c:/Program Files (x86)/Microsoft Visual Studio/<version>/<Professional | Community>/VC/Tools/MSVC/<MS Tools version>/lib/x64/delayimp.lib
// to: <game repository>/Plugins/OnlineSubsystemGOG/Source/ThirdParty/GalaxySDK/Libraries/
PublicAdditionalLibraries.Add("delayimp.lib");
PublicDelayLoadDLLs.Add(galaxyDLLName);
}
else
{
string Err = string.Format("Unsupported platform: {0}", Target.Platform);
System.Console.WriteLine(Err);
throw new BuildException(Err);
}
AddPublicDefinition("GALAXY_DLL_NAME=" + galaxyDLLName);
AddRuntimeDependency(Path.Combine(LibrariesPath, galaxyDLLName));
}
public Steamworks(ReadOnlyTargetRules Target) : base(Target)
{
/** Mark the current version of the Steam SDK */
string SteamVersion = "v139";
Type = ModuleType.External;
PublicDefinitions.Add("STEAM_SDK_VER=TEXT(\"1.39\")");
PublicDefinitions.Add("STEAM_SDK_VER_PATH=TEXT(\"Steam" + SteamVersion + "\")");
string SdkBase = Target.UEThirdPartySourceDirectory + "Steamworks/Steam" + SteamVersion + "/sdk";
if (!Directory.Exists(SdkBase))
{
string Err = string.Format("steamworks SDK not found in {0}", SdkBase);
System.Console.WriteLine(Err);
throw new BuildException(Err);
}
PublicIncludePaths.Add(SdkBase + "/public");
string LibraryPath = SdkBase + "/redistributable_bin/";
string LibraryName = "steam_api";
if (Target.Platform == UnrealTargetPlatform.Win32)
{
PublicLibraryPaths.Add(LibraryPath);
PublicAdditionalLibraries.Add(LibraryName + ".lib");
PublicDelayLoadDLLs.Add(LibraryName + ".dll");
string SteamBinariesDir = String.Format("$(EngineDir)/Binaries/ThirdParty/Steamworks/Steam{0}/Win32/", SteamVersion);
RuntimeDependencies.Add(SteamBinariesDir + "steam_api.dll");
if (Target.Type == TargetType.Server)
{
RuntimeDependencies.Add(SteamBinariesDir + "steamclient.dll");
RuntimeDependencies.Add(SteamBinariesDir + "tier0_s.dll");
RuntimeDependencies.Add(SteamBinariesDir + "vstdlib_s.dll");
}
else
{
// assume SteamController is needed
RuntimeDependencies.Add("$(EngineDir)/Config/controller.vdf");
}
}
else if (Target.Platform == UnrealTargetPlatform.Win64)
{
PublicLibraryPaths.Add(LibraryPath + "win64");
PublicAdditionalLibraries.Add(LibraryName + "64.lib");
PublicDelayLoadDLLs.Add(LibraryName + "64.dll");
string SteamBinariesDir = String.Format("$(EngineDir)/Binaries/ThirdParty/Steamworks/Steam{0}/Win64/", SteamVersion);
RuntimeDependencies.Add(SteamBinariesDir + LibraryName + "64.dll");
if (Target.Type == TargetType.Server)
{
RuntimeDependencies.Add(SteamBinariesDir + "steamclient64.dll");
RuntimeDependencies.Add(SteamBinariesDir + "tier0_s64.dll");
RuntimeDependencies.Add(SteamBinariesDir + "vstdlib_s64.dll");
}
else
{
// assume SteamController is needed
RuntimeDependencies.Add("$(EngineDir)/Config/controller.vdf");
}
}
else if (Target.Platform == UnrealTargetPlatform.Mac)
{
LibraryPath += "osx32/libsteam_api.dylib";
PublicDelayLoadDLLs.Add(LibraryPath);
PublicAdditionalShadowFiles.Add(LibraryPath);
AdditionalBundleResources.Add(new UEBuildBundleResource(LibraryPath, "MacOS"));
}
else if (Target.Platform == UnrealTargetPlatform.Linux)
{
if (Target.LinkType == TargetLinkType.Monolithic)
{
LibraryPath += "linux64";
PublicLibraryPaths.Add(LibraryPath);
PublicAdditionalLibraries.Add(LibraryName);
}
else
{
LibraryPath += "linux64/libsteam_api.so";
PublicDelayLoadDLLs.Add(LibraryPath);
}
string SteamBinariesPath = String.Format(Target.UEThirdPartyBinariesDirectory + "Steamworks/Steam{0}/{1}/{2}", SteamVersion, Target.Architecture, "libsteam_api.so");
PublicAdditionalLibraries.Add(SteamBinariesPath);
RuntimeDependencies.Add(SteamBinariesPath);
}
}
public llvm(ReadOnlyTargetRules Target) : base(Target)
{
Type = ModuleType.External;
if (Target.Platform != UnrealTargetPlatform.Win32)
{
// Currently we support only Win32 llvm builds.
return;
}
var LLVMVersion = @"3.5.0";
// VS2015 uses a newer version of the libs
if (Target.WindowsPlatform.Compiler == WindowsCompiler.VisualStudio2015)
{
LLVMVersion = @"3.6.2";
}
var VSVersion = @"vs" + Target.WindowsPlatform.GetVisualStudioCompilerVersionName();
var TargetArch = @"x86";
var RootDirectory = Path.Combine(Target.UEThirdPartySourceDirectory, @"llvm", LLVMVersion);
PublicIncludePaths.AddRange(
new string[] {
Path.Combine(RootDirectory, "include"),
});
PublicLibraryPaths.AddRange(
new string[] {
Path.Combine(RootDirectory, @"lib", VSVersion, TargetArch, @"release"),
});
PublicAdditionalLibraries.AddRange(
new string[] {
"clangAnalysis.lib",
"clangAST.lib",
"clangBasic.lib",
"clangDriver.lib",
"clangEdit.lib",
"clangFrontend.lib",
"clangLex.lib",
"clangParse.lib",
"clangSema.lib",
"clangSerialization.lib",
"clangTooling.lib",
"LLVMAnalysis.lib",
"LLVMBitReader.lib",
"LLVMCodegen.lib",
"LLVMCore.lib",
"LLVMMC.lib",
"LLVMMCDisassembler.lib",
"LLVMMCParser.lib",
"LLVMObject.lib",
"LLVMOption.lib",
"LLVMSupport.lib",
"LLVMTarget.lib",
"LLVMX86AsmParser.lib",
"LLVMX86AsmPrinter.lib",
"LLVMX86CodeGen.lib",
"LLVMX86Desc.lib",
"LLVMX86Info.lib",
"LLVMX86Utils.lib",
});
// The 3.6.2 version we use for VS2015 has moved some functionality around.
if (Target.WindowsPlatform.Compiler == WindowsCompiler.VisualStudio2015)
{
PublicAdditionalLibraries.AddRange(
new string[] {
"LLVMTransformUtils.lib",
});
}
}
public WorldBrowser(ReadOnlyTargetRules Target) : base(Target)
{
PublicIncludePaths.Add("Editor/WorldBrowser/Public");
PrivateIncludePaths.Add("Editor/WorldBrowser/Private"); // For PCH includes (because they don't work with relative paths, yet)
PrivateIncludePathModuleNames.AddRange(
new string[] {
"AssetRegistry",
"AssetTools",
"ContentBrowser",
"Landscape",
"MeshUtilities",
"MaterialUtilities",
"MeshMergeUtilities",
}
);
PrivateDependencyModuleNames.AddRange(
new string[] {
"AppFramework",
"Core",
"CoreUObject",
"RenderCore",
"ShaderCore",
"InputCore",
"Engine",
"Landscape",
"Slate",
"SlateCore",
"EditorStyle",
"UnrealEd",
"GraphEditor",
"LevelEditor",
"PropertyEditor",
"DesktopPlatform",
"MainFrame",
"SourceControl",
"SourceControlWindows",
"RawMesh",
"LandscapeEditor",
"FoliageEdit",
"ImageWrapper",
"Foliage",
"MaterialUtilities",
"RHI",
"Json",
}
);
DynamicallyLoadedModuleNames.AddRange(
new string[] {
"AssetRegistry",
"AssetTools",
"SceneOutliner",
"MeshUtilities",
"ContentBrowser",
"MeshMergeUtilities",
}
);
}
public OptickPlugin(ReadOnlyTargetRules Target) : base(Target)
{
PublicIncludePaths.AddRange(
new string[] {
// ... add public include paths required here ...
}
);
PrivateIncludePaths.AddRange(
new string[] {
"Private",
"ThirdParty/Optick/src",
// ... add other private include paths required here ...
}
);
PublicDependencyModuleNames.AddRange(
new string[]
{
"Core",
"CoreUObject",
"Engine",
"EngineSettings",
"RenderCore",
"RHI",
// ... 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 ...
}
);
PublicDefinitions.AddRange(
new string[]
{
"OPTICK_ENABLE_GPU_VULKAN=0",
"OPTICK_ENABLE_GPU_D3D12=0",
"_CRT_SECURE_NO_WARNINGS",
"OPTICK_UE4=1",
}
);
/*
#if UE_4_24_OR_LATER
* PublicDefinitions.AddRange(
* new string[]
* {
* "OPTICK_UE4_GPU=1",
* }
* );
#endif
*/
PublicDefinitions.AddRange(
new string[]
{
"OPTICK_UE4_GPU=0",
}
);
if (Target.bBuildEditor == true)
{
PublicDependencyModuleNames.AddRange(
new string[]
{
"Slate",
"SlateCore",
"EditorStyle",
"UnrealEd",
"MainFrame",
"GameProjectGeneration",
"Projects",
"InputCore",
"LevelEditor",
"DesktopPlatform",
}
);
}
//PCHUsage = ModuleRules.PCHUsageMode.UseExplicitOrSharedPCHs;
}