public GameProjectGeneration(ReadOnlyTargetRules Target) : base(Target)
{
PublicDependencyModuleNames.AddRange(
new string[] {
"HardwareTargeting",
}
);
PrivateIncludePathModuleNames.AddRange(
new string[] {
"AssetRegistry",
"ContentBrowser",
"DesktopPlatform",
"LauncherPlatform",
"MainFrame",
"AddContentDialog",
"HardwareTargeting",
}
);
PrivateDependencyModuleNames.AddRange(
new string[] {
"Analytics",
"ApplicationCore",
"AppFramework",
"ClassViewer",
"Core",
"CoreUObject",
"Engine",
"EngineSettings",
"InputCore",
"Projects",
"RenderCore",
"Slate",
"SlateCore",
"EditorStyle",
"SourceControl",
"TargetPlatform",
"UnrealEd",
"DesktopPlatform",
"LauncherPlatform",
"HardwareTargeting",
"AddContentDialog",
"AudioMixer"
}
);
DynamicallyLoadedModuleNames.AddRange(
new string[] {
"AssetRegistry",
"ContentBrowser",
"Documentation",
"MainFrame",
}
);
if (Target.bWithLiveCoding)
{
PrivateIncludePathModuleNames.Add("LiveCoding");
}
}
public PrFirebase(ReadOnlyTargetRules Target) : base(Target)
{
PCHUsage = ModuleRules.PCHUsageMode.UseExplicitOrSharedPCHs;
ConfigHierarchy EngineConfig = ConfigCache.ReadHierarchy(ConfigHierarchyType.Engine, DirectoryReference.FromFile(Target.ProjectFile), Target.Platform);
bool bFirebaseLoggingInShipping = false;
EngineConfig.TryGetValue("/Script/PrFirebase.PrFirebaseSettings", "bFirebaseLoggingInShipping", out bFirebaseLoggingInShipping);
bool bFirebaseEnable = false;
bool bFirebaseCrashlyticsEnable = false;
bool bFirebaseRemoteConfigEnable = false;
bool bFirebaseAuthEnable = false;
bool bFirebasePerformanceEnable = false;
EngineConfig.TryGetValue("/Script/PrFirebase.PrFirebaseSettings", "bFirebaseEnable", out bFirebaseEnable);
EngineConfig.TryGetValue("/Script/PrFirebase.PrFirebaseSettings", "bFirebaseCrashlyticsEnable", out bFirebaseCrashlyticsEnable);
EngineConfig.TryGetValue("/Script/PrFirebase.PrFirebaseSettings", "bFirebaseRemoteConfigEnable", out bFirebaseRemoteConfigEnable);
EngineConfig.TryGetValue("/Script/PrFirebase.PrFirebaseSettings", "bFirebaseAuthEnable", out bFirebaseAuthEnable);
EngineConfig.TryGetValue("/Script/PrFirebase.PrFirebaseSettings", "bFirebasePerformanceEnable", out bFirebasePerformanceEnable);
PrivateIncludePaths.AddRange(
new string[] {
"PrFirebase/Private"
});
PublicDependencyModuleNames.AddRange(
new string[] {
"Core",
"CoreUObject",
"Engine"
});
PrivateIncludePathModuleNames.AddRange(
new string[] {
"Settings",
}
);
bool bSymbolsWarning = false;
if (bFirebaseEnable)
{
if (Target.Platform == UnrealTargetPlatform.IOS)
{
bool bGeneratedSYMBundle = false;
bool bGeneratedSYMFile = false;
EngineConfig.TryGetValue("/Script/IOSRuntimeSettings.IOSRuntimeSettings", "bGeneratedSYMBundle", out bGeneratedSYMBundle);
EngineConfig.TryGetValue("/Script/IOSRuntimeSettings.IOSRuntimeSettings", "bGeneratedSYMFile", out bGeneratedSYMFile);
if ((!bGeneratedSYMBundle || !bGeneratedSYMFile) && bFirebaseCrashlyticsEnable)
{
bSymbolsWarning = true;
}
/* Firebase / Firebase Analytics */
PublicAdditionalFrameworks.Add(
new Framework(
"FIRAnalyticsConnector",
"../../ThirdParty/iOS/FIRAnalyticsConnector.embeddedframework.zip"
)
);
PublicAdditionalFrameworks.Add(
new Framework(
"FirebaseAnalytics",
"../../ThirdParty/iOS/FirebaseAnalytics.embeddedframework.zip"
)
);
PublicAdditionalFrameworks.Add(
new Framework(
"FirebaseCore",
"../../ThirdParty/iOS/FirebaseCore.embeddedframework.zip"
)
);
PublicAdditionalFrameworks.Add(
new Framework(
"FirebaseCoreDiagnostics",
"../../ThirdParty/iOS/FirebaseCoreDiagnostics.embeddedframework.zip"
)
);
PublicAdditionalFrameworks.Add(
new Framework(
"FirebaseInstallations",
"../../ThirdParty/iOS/FirebaseInstallations.embeddedframework.zip"
)
);
PublicAdditionalFrameworks.Add(
new Framework(
"GoogleAppMeasurement",
"../../ThirdParty/iOS/GoogleAppMeasurement.embeddedframework.zip"
)
);
PublicAdditionalFrameworks.Add(
new Framework(
"GoogleDataTransport",
"../../ThirdParty/iOS/GoogleDataTransport.embeddedframework.zip"
)
);
PublicAdditionalFrameworks.Add(
new Framework(
"GoogleUtilities",
"../../ThirdParty/iOS/GoogleUtilities.embeddedframework.zip"
)
);
PublicAdditionalFrameworks.Add(
new Framework(
"nanopb",
"../../ThirdParty/iOS/nanopb.embeddedframework.zip"
)
);
PublicAdditionalFrameworks.Add(
new Framework(
"PromisesObjC",
"../../ThirdParty/iOS/PromisesObjC.embeddedframework.zip"
)
);
/* Crashlytics */
if (bFirebaseCrashlyticsEnable)
{
PublicAdditionalFrameworks.Add(
new Framework(
"FirebaseCrashlytics",
"../../ThirdParty/iOS/FirebaseCrashlytics.embeddedframework.zip"
)
);
}
/* Remote Config */
if (bFirebaseRemoteConfigEnable)
{
PublicAdditionalFrameworks.Add(
new Framework(
"FirebaseABTesting",
"../../ThirdParty/iOS/FirebaseABTesting.embeddedframework.zip"
)
);
PublicAdditionalFrameworks.Add(
new Framework(
"FirebaseRemoteConfig",
"../../ThirdParty/iOS/FirebaseRemoteConfig.embeddedframework.zip"
)
);
PublicAdditionalFrameworks.Add(
new Framework(
"Protobuf",
"../../ThirdParty/iOS/Protobuf.embeddedframework.zip"
)
);
}
/* Performance */
if (bFirebasePerformanceEnable)
{
PublicAdditionalFrameworks.Add(
new Framework(
"FirebaseABTesting",
"../../ThirdParty/iOS/FirebaseABTesting.embeddedframework.zip"
)
);
PublicAdditionalFrameworks.Add(
new Framework(
"FirebasePerformance",
"../../ThirdParty/iOS/FirebasePerformance.embeddedframework.zip"
)
);
PublicAdditionalFrameworks.Add(
new Framework(
"FirebaseRemoteConfig",
"../../ThirdParty/iOS/FirebaseRemoteConfig.embeddedframework.zip"
)
);
PublicAdditionalFrameworks.Add(
new Framework(
"GoogleToolboxForMac",
"../../ThirdParty/iOS/GoogleToolboxForMac.embeddedframework.zip"
)
);
PublicAdditionalFrameworks.Add(
new Framework(
"GTMSessionFetcher",
"../../ThirdParty/iOS/GTMSessionFetcher.embeddedframework.zip"
)
);
PublicAdditionalFrameworks.Add(
new Framework(
"Protobuf",
"../../ThirdParty/iOS/Protobuf.embeddedframework.zip"
)
);
}
/* Auth */
if (bFirebaseAuthEnable)
{
PublicAdditionalFrameworks.Add(
new Framework(
"FirebaseAuth",
"../../ThirdParty/iOS/FirebaseAuth.embeddedframework.zip"
)
);
PublicAdditionalFrameworks.Add(
new Framework(
"GTMSessionFetcher",
"../../ThirdParty/iOS/GTMSessionFetcher.embeddedframework.zip"
)
);
}
PublicSystemLibraries.Add("sqlite3");
PrivateIncludePaths.Add("PrFirebase/External/iOS");
string PluginPath = Utils.MakePathRelativeTo(ModuleDirectory, Target.RelativeEnginePath);
AdditionalPropertiesForReceipt.Add("IOSPlugin", Path.Combine(PluginPath, "PrFirebase_UPL_IOS.xml"));
}
else if (Target.Platform == UnrealTargetPlatform.Android)
{
PublicDependencyModuleNames.AddRange(
new string[]
{
"Launch"
});
string PluginPath = Utils.MakePathRelativeTo(ModuleDirectory, Target.RelativeEnginePath);
AdditionalPropertiesForReceipt.Add("AndroidPlugin", Path.Combine(PluginPath, "PrFirebase_UPL_Android.xml"));
}
else
{
bFirebaseEnable = false;
}
}
PublicDefinitions.Add("WITH_FIREBASE=" + (bFirebaseEnable ? "1" : "0"));
PublicDefinitions.Add("WITH_FIREBASE_CRASHLYTICS=" + (bFirebaseEnable && bFirebaseCrashlyticsEnable ? "1" : "0"));
PublicDefinitions.Add("WITH_FIREBASE_REMOTECONFIG=" + (bFirebaseEnable && bFirebaseRemoteConfigEnable ? "1" : "0"));
PublicDefinitions.Add("WITH_FIREBASE_AUTH=" + (bFirebaseEnable && bFirebaseAuthEnable ? "1" : "0"));
PublicDefinitions.Add("WITH_FIREBASE_PERFORMANCE=" + (bFirebaseEnable && bFirebasePerformanceEnable ? "1" : "0"));
PublicDefinitions.Add("WITH_FIREBASE_SYMBOLS_WARNING=" + (bFirebaseEnable && bSymbolsWarning ? "1" : "0"));
PublicDefinitions.Add("FIREBASE_LOGGING=" + (bFirebaseLoggingInShipping ? "1" : "0"));
}
public GetMaterialAndObj(ReadOnlyTargetRules Target) : base(Target)
{
PCHUsage = ModuleRules.PCHUsageMode.UseExplicitOrSharedPCHs;
PublicIncludePaths.AddRange(
new string[] {
"GetMaterialAndObj/Public"
// ... add public include paths required here ...
}
);
PrivateIncludePaths.AddRange(
new string[] {
"GetMaterialAndObj/Private",
// ... add other private include paths required here ...
}
);
PublicIncludePathModuleNames.AddRange(
new string[] {
"HierarchicalLODUtilities",
"MeshUtilities",
"MeshReductionInterface",
}
);
PrivateIncludePathModuleNames.AddRange(
new string[] {
"HierarchicalLODUtilities",
"MeshUtilities",
"MeshReductionInterface",
"MaterialBaking",
}
);
PublicDependencyModuleNames.AddRange(
new string[]
{
"Core",
// ... add other public dependencies that you statically link with here ...
"MeshUtilities",
"MaterialUtilities",
"RawMesh",
}
);
PrivateDependencyModuleNames.AddRange(
new string[]
{
"Projects",
"InputCore",
"UnrealEd",
"LevelEditor",
"CoreUObject",
"Engine",
"Slate",
"SlateCore",
// ... add private dependencies that you statically link with here ...
"Core",
"CoreUObject",
"Engine",
"RenderCore",
"Renderer",
"RHI",
"Landscape",
"UnrealEd",
"ShaderCore",
"MaterialUtilities",
"SlateCore",
"Slate",
"StaticMeshEditor",
"SkeletalMeshEditor",
"MaterialBaking",
"MeshMergeUtilities"
}
);
DynamicallyLoadedModuleNames.AddRange(
new string[]
{
// ... add any modules that your module loads dynamically here ...
"HierarchicalLODUtilities",
"MeshReductionInterface",
}
);
}
public MeshModelingTools(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[]
{
// These dependencies were commented out when we split out MeshModelingToolsEditorOnly
// Many of them are editor only and should not be depended on here. If you re-add any
// dependent modules, please confirm by "launching" or packaging that you are not introducing
// editor dependencies
//
//"MeshDescription",
//"ProxyLODMeshReduction", // currently required to be public due to IVoxelBasedCSG API
"Core",
"Eigen",
"InteractiveToolsFramework",
"GeometricObjects",
"GeometryAlgorithms",
"DynamicMesh",
"MeshConversion",
"MeshDescription",
"StaticMeshDescription",
"ModelingComponents",
"ModelingOperators",
// ... add other public dependencies that you statically link with here ...
}
);
PrivateDependencyModuleNames.AddRange(
new string[]
{
// These dependencies were commented out when we split out MeshModelingToolsEditorOnly
// Many of them are editor only and should not be depended on here. If you re-add any
// dependent modules, please confirm by "launching" or packaging that you are not introducing
// editor dependencies
//
//"RenderCore",
//"RHI",
//"MeshUtilities", // temp for saving mesh asset
//"UnrealEd",
//"MeshBuilder",
//"MeshDescriptionOperations",
//"MeshUtilitiesCommon",
//"MeshReductionInterface", // for UE4 standard simplification
//"ProxyLODMeshReduction", // for mesh merging voxel-based csg
//"Slate",
//"SlateCore",
"CoreUObject",
"Engine",
"RenderCore",
"ModelingOperators",
"InputCore",
"PhysicsCore"
// ... add private dependencies that you statically link with here ...
}
);
DynamicallyLoadedModuleNames.AddRange(
new string[]
{
// ... add any modules that your module loads dynamically here ...
}
);
}
public ImGui(TargetInfo Target)
#endif
{
#if WITH_FORWARDED_MODULE_RULES_CTOR
bool bBuildEditor = Target.bBuildEditor;
#else
bool bBuildEditor = (Target.Type == TargetRules.TargetType.Editor);
#endif
PublicIncludePaths.AddRange(
new string[] {
"ImGui/Public",
Path.Combine(ModuleDirectory, "../ThirdParty/ImGuiLibrary/Include")
// ... add public include paths required here ...
}
);
PrivateIncludePaths.AddRange(
new string[] {
"ImGui/Private",
"ThirdParty/ImGuiLibrary/Private"
// ... add other private include paths required here ...
}
);
PublicDependencyModuleNames.AddRange(
new string[]
{
"Core",
"Projects"
// ... add other public dependencies that you statically link with here ...
}
);
PrivateDependencyModuleNames.AddRange(
new string[]
{
"CoreUObject",
"Engine",
"InputCore",
"Slate",
"SlateCore"
// ... add private dependencies that you statically link with here ...
}
);
if (bBuildEditor)
{
PrivateDependencyModuleNames.AddRange(
new string[]
{
"Settings",
"UnrealEd",
}
);
}
DynamicallyLoadedModuleNames.AddRange(
new string[]
{
// ... add any modules that your module loads dynamically here ...
}
);
}
public LandscapeGen(ReadOnlyTargetRules Target) : base(Target)
{
PCHUsage = PCHUsageMode.UseExplicitOrSharedPCHs;
PublicDependencyModuleNames.AddRange(new string[] { "Core", "CoreUObject", "Engine", "InputCore", "HeadMountedDisplay", "ProceduralMeshComponent", "Http", "Json", "JsonUtilities" });
}
public HoudiniEngineRuntime(ReadOnlyTargetRules Target) : base(Target)
{
bPrecompile = true;
PCHUsage = PCHUsageMode.NoSharedPCHs;
PrivatePCHHeaderFile = "Private/HoudiniEngineRuntimePrivatePCH.h";
// Check if we are compiling for unsupported platforms.
if (Target.Platform != UnrealTargetPlatform.Win64 &&
Target.Platform != UnrealTargetPlatform.Mac &&
Target.Platform != UnrealTargetPlatform.Linux &&
Target.Platform != UnrealTargetPlatform.Switch)
{
System.Console.WriteLine(string.Format("Houdini Engine Runtime: Compiling for untested target platform. Please let us know how it goes!"));
}
PublicIncludePaths.AddRange(
new string[] {}
);
PrivateIncludePaths.AddRange(
new string[] { }
);
// Add common dependencies.
PublicDependencyModuleNames.AddRange(
new string[]
{
"Core",
"CoreUObject",
"Engine",
"RenderCore",
"InputCore",
"RHI",
"Foliage",
"Landscape",
"MeshUtilitiesCommon",
"Chaos",
"GeometryCollectionEngine"
}
);
PrivateDependencyModuleNames.AddRange(
new string[]
{
"Landscape",
"PhysicsCore"
}
);
if (Target.bBuildEditor == true)
{
PrivateDependencyModuleNames.AddRange(
new string[]
{
"UnrealEd",
"Kismet",
}
);
}
}
public Runner(TargetInfo Target)
{
PublicDependencyModuleNames.AddRange(new string[] { "Core", "CoreUObject", "Engine", "InputCore" });
}
public UMGEditor(ReadOnlyTargetRules Target) : base(Target)
{
PrivateIncludePaths.AddRange(
new string[] {
"Editor/UMGEditor/Private", // For PCH includes (because they don't work with relative paths, yet)
"Editor/UMGEditor/Private/Templates",
"Editor/UMGEditor/Private/Extensions",
"Editor/UMGEditor/Private/Customizations",
"Editor/UMGEditor/Private/BlueprintModes",
"Editor/UMGEditor/Private/TabFactory",
"Editor/UMGEditor/Private/Designer",
"Editor/UMGEditor/Private/Hierarchy",
"Editor/UMGEditor/Private/Palette",
"Editor/UMGEditor/Private/Details",
"Editor/UMGEditor/Private/DragDrop",
"Editor/UMGEditor/Private/Utility",
});
PrivateIncludePathModuleNames.AddRange(
new string[] {
"AssetTools",
"UMG",
});
PublicDependencyModuleNames.AddRange(
new string[]
{
"Sequencer",
});
PrivateDependencyModuleNames.AddRange(
new string[] {
"Core",
"CoreUObject",
"ApplicationCore",
"InputCore",
"Slate",
"Engine",
"AssetTools",
"UnrealEd", // for FAssetEditorManager
"KismetWidgets",
"KismetCompiler",
"BlueprintGraph",
"GraphEditor",
"Kismet", // for FWorkflowCentricApplication
"PropertyEditor",
"UMG",
"EditorStyle",
"Slate",
"SlateCore",
"MessageLog",
"MovieScene",
"MovieSceneTools",
"MovieSceneTracks",
"DetailCustomizations",
"Settings",
"RenderCore",
"TargetPlatform",
"TimeManagement",
"GameProjectGeneration"
}
);
}
public S05_TestingGrounds(TargetInfo Target)
{
PublicDependencyModuleNames.AddRange(new string[] { "Core", "CoreUObject", "Engine", "InputCore", "HeadMountedDisplay", "AIModule", "GameplayTasks" });
}
public PuzzlePlatformer(ReadOnlyTargetRules Target) : base(Target)
{
PCHUsage = PCHUsageMode.UseExplicitOrSharedPCHs;
PublicDependencyModuleNames.AddRange(new string[] { "Core", "CoreUObject", "Engine", "InputCore", "HeadMountedDisplay", "UMG", "OnlineSubsystem", "OnlineSubsystemSteam" });
}
public UnrealEnginePython(TargetInfo Target)
#endif
{
PCHUsage = ModuleRules.PCHUsageMode.UseExplicitOrSharedPCHs;
PublicDefinitions.Add("WITH_UNREALENGINEPYTHON=1"); // fixed
string enableUnityBuild = System.Environment.GetEnvironmentVariable("UEP_ENABLE_UNITY_BUILD");
bUseUnity = string.IsNullOrEmpty(enableUnityBuild);
PublicIncludePaths.AddRange(
new string[] {
Path.Combine(ModuleDirectory, "Public"),
// ... add public include paths required here ...
}
);
PrivateIncludePaths.AddRange(
new string[] {
Path.Combine(ModuleDirectory, "Private"),
PythonHome,
// ... add other private include paths required here ...
}
);
PublicDependencyModuleNames.AddRange(
new string[]
{
"Core",
"Sockets",
"Networking",
"Projects"
// ... 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",
"AIModule"
// ... 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 (UseThirdPartyPython)
{
PythonHome = ThirdPartyPythonHome;
System.Console.WriteLine("Using Embedded Python at: " + PythonHome);
PublicIncludePaths.Add(PythonHome);
string libPath = Path.Combine(PythonHome, "Lib", string.Format("{0}.lib", PythonType.ToLower()));
System.Console.WriteLine("full lib path: " + libPath);
PublicLibraryPaths.Add(Path.GetDirectoryName(libPath));
PublicAdditionalLibraries.Add(libPath);
string dllPath = Path.Combine(BinariesPath, "Win64", string.Format("{0}.dll", PythonType.ToLower()));
RuntimeDependencies.Add(dllPath);
AddRuntimeDependenciesForCopying(Target);
}
else if (PythonHome == "")
{
PythonHome = DiscoverPythonPath(windowsKnownPaths, "Win64");
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);
}
}
//other platforms
else
{
if (PythonHome == "")
{
PythonHome = DiscoverPythonPath(macKnownPaths, "Mac");
if (PythonHome == "")
{
throw new System.Exception("Unable to find Python installation");
}
System.Console.WriteLine("Using Python at: " + PythonHome);
PublicIncludePaths.Add(PythonHome);
PublicAdditionalLibraries.Add(Path.Combine(PythonHome, "Lib", string.Format("{0}.lib", PythonType)));
}
System.Console.WriteLine("Using Python at: " + PythonHome);
PublicIncludePaths.Add(PythonHome);
string libPath = GetMacPythonLibFile(PythonHome);
PublicLibraryPaths.Add(Path.GetDirectoryName(libPath));
PublicDelayLoadDLLs.Add(libPath);
}
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]);
}
}
#if WITH_FORWARDED_MODULE_RULES_CTOR
else if (Target.Platform == UnrealTargetPlatform.Android)
{
PublicIncludePaths.Add(System.IO.Path.Combine(ModuleDirectory, "../../android/python35/include"));
PublicAdditionalLibraries.Add(System.IO.Path.Combine(ModuleDirectory, "../../android/armeabi-v7a"));
PublicAdditionalLibraries.Add("python3.5m");
string APLName = "UnrealEnginePython_APL.xml";
string RelAPLPath = Utils.MakePathRelativeTo(ModuleDirectory, Target.RelativeEnginePath);
AdditionalPropertiesForReceipt.Add("AndroidPlugin", Path.Combine(RelAPLPath, APLName));
}
#endif
}
public MLR_BP2(ReadOnlyTargetRules Target) : base(Target)
{
PCHUsage = PCHUsageMode.UseExplicitOrSharedPCHs;
PublicDependencyModuleNames.AddRange(new string[] { "Core", "CoreUObject", "Engine", "InputCore", "HeadMountedDisplay", "SocketIOClient", "SocketIOLib", "Json", "JsonUtilities", "SIOJson" });
}
public KantanCodeExamplesCommon(TargetInfo Target)
{
PublicDependencyModuleNames.AddRange(new string[] { "Core", "CoreUObject", "Engine", "InputCore" });
}
public EQSTest(ReadOnlyTargetRules Target) : base(Target)
{
PCHUsage = PCHUsageMode.UseExplicitOrSharedPCHs;
PublicDependencyModuleNames.AddRange(new string[] { "Core", "CoreUObject", "Engine", "InputCore", "HeadMountedDisplay", "NavigationSystem", "AIModule" });
}
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",
"AnimationBlueprintEditor",
"AnimationEditor",
"SkeletalMeshEditor",
"SkeletonEditor",
"PropertyEditor",
"EditorStyle",
"GraphColor",
"MeshBuilder",
"MeshUtilitiesCommon",
}
);
PublicIncludePathModuleNames.AddRange(
new string[] {
"MeshMergeUtilities"
}
);
PrivateIncludePathModuleNames.AddRange(
new string[] {
"MeshMergeUtilities",
"MaterialBaking",
}
);
DynamicallyLoadedModuleNames.AddRange(
new string[] {
"MeshMergeUtilities",
"MaterialBaking",
}
);
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");
}
if (Target.bCompileSimplygon == true)
{
AddEngineThirdPartyPrivateDynamicDependencies(Target, "SimplygonMeshReduction");
if (Target.bCompileSimplygonSSF == true)
{
DynamicallyLoadedModuleNames.AddRange(
new string[] {
"SimplygonSwarm"
}
);
}
}
// EMBREE
if (Target.Platform == UnrealTargetPlatform.Win64)
{
string SDKDir = Target.UEThirdPartySourceDirectory + "IntelEmbree/Embree2140/Win64/";
PublicIncludePaths.Add(SDKDir + "include");
PublicLibraryPaths.Add(SDKDir + "lib");
PublicAdditionalLibraries.Add("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");
PublicDefinitions.Add("USE_EMBREE=1");
}
else
{
PublicDefinitions.Add("USE_EMBREE=0");
}
}
public SpoutPlugin(ReadOnlyTargetRules Target) : base(Target)
{
PublicIncludePaths.AddRange(
new string[] {
"SpoutPlugin/Public",
Path.Combine(ThirdPartyPath, "Spout/include")
// ... add public include paths required here ...
}
);
PrivateIncludePaths.AddRange(
new string[] {
"SpoutPlugin/Private",
// ... add other private include paths required here ...
}
);
//AddThirdPartyPrivateStaticDependencies(Target, "Spout");
PublicDependencyModuleNames.AddRange(
new string[]
{
"Core",
"CoreUObject",
"Engine",
"RHI",
"RenderCore"
// ... 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[]
{
// ... add any modules that your module loads dynamically here ...
}
);
if ((Target.Platform == UnrealTargetPlatform.Win64) || (Target.Platform == UnrealTargetPlatform.Win32))
{
string PlatformString = (Target.Platform == UnrealTargetPlatform.Win64) ? "amd64" : "x86";
PublicAdditionalLibraries.Add(Path.Combine(ThirdPartyPath, "Spout/lib", PlatformString, "Spout.lib"));
RuntimeDependencies.Add(new RuntimeDependency(Path.Combine(ThirdPartyPath, "Spout/lib", PlatformString, "Spout.dll")));
// Delay-load the DLL, so we can load it from the right place first
PublicDelayLoadDLLs.Add(Path.Combine(ThirdPartyPath, "Spout/lib", PlatformString, "Spout.dll"));
}
}
public TestingGroundsFPS(TargetInfo Target)
{
PublicDependencyModuleNames.AddRange(new string[] { "Core", "CoreUObject", "Engine", "InputCore", "HeadMountedDisplay" });
}
public TestingGrounds_05(ReadOnlyTargetRules Target) : base(Target)
{
PCHUsage = PCHUsageMode.UseExplicitOrSharedPCHs;
PublicDependencyModuleNames.AddRange(new string[] { "Core", "CoreUObject", "Engine", "InputCore", "HeadMountedDisplay", "AIModule", "GameplayTasks" });
}
public BloodInvaders(ReadOnlyTargetRules Target) : base(Target)
{
PCHUsage = PCHUsageMode.UseExplicitOrSharedPCHs;
PublicDependencyModuleNames.AddRange(new string[] { "Core", "CoreUObject", "Engine", "InputCore" });
}
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",
}
);
PublicIncludePaths.AddRange(
new string[]
{
"Developer/FriendsAndChat/Public/Models",
"Developer/FriendsAndChat/Public/Interfaces"
}
);
DynamicallyLoadedModuleNames.AddRange(
new string[] {
"HTTP",
"EditorStyle",
"OnlineSubsystem"
}
);
PrivateIncludePathModuleNames.AddRange(
new string[] {
"HTTP",
"EditorStyle",
}
);
if (UEBuildConfiguration.bCompileMcpOSS == true)
{
PublicDependencyModuleNames.AddRange(
new string[]
{
"OnlineSubsystemMcp",
}
);
PrivateDependencyModuleNames.AddRange(
new string[]
{
"OnlineSubsystemMcp",
}
);
DynamicallyLoadedModuleNames.AddRange(
new string[]
{
"OnlineSubsystemMcp",
}
);
}
}
public WindowsMixedRealityHMD(ReadOnlyTargetRules Target) : base(Target)
{
bEnableExceptions = true;
if (Target.Platform == UnrealTargetPlatform.Win32 ||
Target.Platform == UnrealTargetPlatform.Win64 ||
Target.Platform == UnrealTargetPlatform.HoloLens)
{
PublicDependencyModuleNames.AddRange(
new string[]
{
"HeadMountedDisplay",
"ProceduralMeshComponent",
"MixedRealityInteropLibrary",
"InputDevice",
}
);
PrivateDependencyModuleNames.AddRange(
new string[]
{
"Core",
"CoreUObject",
"ApplicationCore",
"Engine",
"EngineSettings",
"InputCore",
"RHI",
"RenderCore",
"Renderer",
"HeadMountedDisplay",
"D3D11RHI",
"Slate",
"SlateCore",
"Projects",
"AugmentedReality",
}
);
if (Target.Platform == UnrealTargetPlatform.Win64 ||
Target.Platform == UnrealTargetPlatform.HoloLens)
{
PrivateDependencyModuleNames.Add("HoloLensAR");
}
if (Target.bBuildEditor == true)
{
PrivateDependencyModuleNames.Add("UnrealEd");
PrivateDependencyModuleNames.Add("WindowsMixedRealityRuntimeSettings");
}
if (Target.Platform != UnrealTargetPlatform.HoloLens)
{
AddEngineThirdPartyPrivateStaticDependencies(Target, "NVAftermath");
AddEngineThirdPartyPrivateStaticDependencies(Target, "IntelMetricsDiscovery");
}
AddEngineThirdPartyPrivateStaticDependencies(Target, "WindowsMixedRealityInterop");
LoadMixedReality(Target);
PrivateIncludePaths.AddRange(
new string[]
{
"WindowsMixedRealityHMD/Private",
"../../../../Source/Runtime/Windows/D3D11RHI/Private",
"../../../../Source/Runtime/Renderer/Private",
});
if (Target.Platform == UnrealTargetPlatform.Win32 ||
Target.Platform == UnrealTargetPlatform.Win64)
{
PrivateIncludePaths.Add("../../../../Source/Runtime/Windows/D3D11RHI/Private/Windows");
}
else if (Target.Platform == UnrealTargetPlatform.HoloLens)
{
PrivateIncludePaths.Add("../../../../Source/Runtime/Windows/D3D11RHI/Private/HoloLens");
}
PCHUsage = PCHUsageMode.NoSharedPCHs;
PrivatePCHHeaderFile = "Private/WindowsMixedRealityPrecompiled.h";
if (Target.Platform == UnrealTargetPlatform.Win64)
{
RuntimeDependencies.Add(System.IO.Path.Combine("$(EngineDir)/Binaries/ThirdParty/Windows/x64", "Microsoft.Azure.SpatialAnchors.dll"));
RuntimeDependencies.Add(System.IO.Path.Combine("$(EngineDir)/Binaries/ThirdParty/Windows/x64", "Microsoft.Azure.SpatialAnchors.winmd"));
PublicDelayLoadDLLs.Add("Microsoft.Azure.SpatialAnchors.dll");
RuntimeDependencies.Add(Path.Combine("$(EngineDir)/Binaries/ThirdParty/Windows/x64", "Microsoft.MixedReality.QR.dll"));
PublicDelayLoadDLLs.Add("Microsoft.MixedReality.QR.dll");
RuntimeDependencies.Add(Path.Combine("$(EngineDir)/Binaries/ThirdParty/Windows/x64", "Microsoft.MixedReality.SceneUnderstanding.dll"));
PublicDelayLoadDLLs.Add("Microsoft.MixedReality.SceneUnderstanding.dll");
PublicDefinitions.Add("WITH_SCENE_UNDERSTANDING=1");
foreach (var Dll in Directory.EnumerateFiles(Path.Combine(Target.UEThirdPartyBinariesDirectory, "Windows/x64"), "*_app.dll"))
{
RuntimeDependencies.Add(Dll);
}
}
else if (Target.Platform == UnrealTargetPlatform.HoloLens)
{
RuntimeDependencies.Add(System.IO.Path.Combine("$(EngineDir)/Binaries/ThirdParty/HoloLens", Target.WindowsPlatform.GetArchitectureSubpath(), "Microsoft.Azure.SpatialAnchors.dll"));
RuntimeDependencies.Add(System.IO.Path.Combine("$(EngineDir)/Binaries/ThirdParty/HoloLens", Target.WindowsPlatform.GetArchitectureSubpath(), "Microsoft.Azure.SpatialAnchors.winmd"));
PublicDelayLoadDLLs.Add("Microsoft.Azure.SpatialAnchors.dll");
PublicDelayLoadDLLs.Add("Microsoft.MixedReality.QR.dll");
RuntimeDependencies.Add(Path.Combine("$(EngineDir)/Binaries/ThirdParty/HoloLens", Target.WindowsPlatform.GetArchitectureSubpath(), "Microsoft.MixedReality.QR.dll"));
string SceneUnderstandingPath = Path.Combine(Target.UEThirdPartyBinariesDirectory, "HoloLens", Target.WindowsPlatform.GetArchitectureSubpath(), "Microsoft.MixedReality.SceneUnderstanding.dll");
if (File.Exists(SceneUnderstandingPath))
{
RuntimeDependencies.Add(SceneUnderstandingPath);
PublicDefinitions.Add("WITH_SCENE_UNDERSTANDING=1");
}
else
{
PublicDefinitions.Add("WITH_SCENE_UNDERSTANDING=0");
}
}
}
if (Target.Platform == UnrealTargetPlatform.Win64 && Target.bBuildEditor == true)
{
PrivateDependencyModuleNames.Add("WindowsMixedRealityInputSimulation");
PrivateDefinitions.Add("WITH_INPUT_SIMULATION=1");
}
else
{
PrivateDefinitions.Add("WITH_INPUT_SIMULATION=0");
}
}
public MyFirstGameWorld(ReadOnlyTargetRules Target) : base(Target)
{
PCHUsage = PCHUsageMode.UseExplicitOrSharedPCHs;
PublicDependencyModuleNames.AddRange(new string[] { "Core", "CoreUObject", "Engine", "InputCore", "AIModule", "GameplayTasks", "HeadMountedDisplay", "UMG", "Slate", "SlateCore" });
}
public AppleARKit(ReadOnlyTargetRules Target) : base(Target)
{
// @todo arkit : just for developing with XCode.
bFasterWithoutUnity = true;
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"
// ... 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)
{
Definitions.Add("ARKIT_SUPPORT=1");
PublicFrameworks.Add("ARKit");
// Do not precompile by default, since it currently requires a beta version of Xcode
PrecompileForTargets = PrecompileTargetsType.None;
}
else
{
Definitions.Add("ARKIT_SUPPORT=0");
}
}
public MeshPaintMode(ReadOnlyTargetRules Target) : base(Target)
{
PrivateIncludePathModuleNames.AddRange(
new string[] {
"AssetRegistry",
"AssetTools"
}
);
PublicDependencyModuleNames.AddRange(
new string[] {
"MeshPaint",
}
);
PrivateDependencyModuleNames.AddRange(
new string[] {
"AppFramework",
"Core",
"CoreUObject",
"DesktopPlatform",
"Engine",
"InputCore",
"RenderCore",
"RHI",
"ShaderCore",
"Slate",
"SlateCore",
"EditorStyle",
"UnrealEd",
"RawMesh",
"SourceControl",
"ViewportInteraction",
"VREditor",
"PropertyEditor",
"MainFrame",
"MeshPaint",
}
);
CircularlyReferencedDependentModules.AddRange(
new string[]
{
"ViewportInteraction",
"VREditor"
}
);
PrivateIncludePathModuleNames.AddRange(
new string[]
{
"AssetTools",
"LevelEditor"
});
DynamicallyLoadedModuleNames.AddRange(
new string[] {
"AssetRegistry",
"AssetTools"
}
);
}
public SpaceMouse(ReadOnlyTargetRules Target) : base(Target)
{
PCHUsage = ModuleRules.PCHUsageMode.UseExplicitOrSharedPCHs;
bEnableUndefinedIdentifierWarnings = false;
CppStandard = CppStandardVersion.Cpp17;
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",
"CoreUObject",
"Engine",
"InputCore",
"SpaceMouseReader"
// ... add other public dependencies that you statically link with here ...
}
);
PrivateDependencyModuleNames.AddRange(
new string[]
{
// ... add private dependencies that you statically link with here ...
}
);
if (Target.Type == TargetType.Editor)
{
PublicDependencyModuleNames.AddRange(
new string[]
{
"Slate",
"SlateCore",
"UnrealEd",
"LevelEditor",
"ApplicationCore"
// ... add private dependencies that you statically link with here ...
}
);
}
DynamicallyLoadedModuleNames.AddRange(
new string[]
{
// ... add any modules that your module loads dynamically here ...
}
);
}
public BidmadPlugin(ReadOnlyTargetRules Target) : base(Target)
{
PCHUsage = ModuleRules.PCHUsageMode.UseExplicitOrSharedPCHs;
//PrivatePCHHeaderFile = "Public/BidmadPluginPCH.h";
PublicIncludePaths.AddRange(
new string[] {
// ... add public include paths required here ...
Path.Combine(ModuleDirectory, "Public"),
"Runtime/Launch/Public" //JNI
}
);
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 ...
}
);
if (Target.Platform == UnrealTargetPlatform.Android)
{
string PluginPath = Utils.MakePathRelativeTo(ModuleDirectory, Target.RelativeEnginePath);
AdditionalPropertiesForReceipt.Add("AndroidPlugin", Path.Combine(PluginPath, "Bidmad_UPL.xml"));
}
else if (Target.Platform == UnrealTargetPlatform.IOS)
{
PublicAdditionalFrameworks.Add(
new Framework(
"AppLovinSDK",
"../../ThirdParty/IOS/AppLovinSDK.embeddedframework.zip"
)
);
PublicAdditionalFrameworks.Add(
new Framework(
"AppLovinAdapter",
"../../ThirdParty/IOS/AppLovinAdapter.embeddedframework.zip"
)
);
PublicAdditionalFrameworks.Add(
new Framework(
"BidmadSDK",
"../../ThirdParty/IOS/BidmadSDK.embeddedframework.zip"
)
);
PublicAdditionalFrameworks.Add(
new Framework(
"FBSDKCoreKit",
"../../ThirdParty/IOS/FBSDKCoreKit.embeddedframework.zip"
)
);
PublicAdditionalFrameworks.Add(
new Framework(
"FBAudienceNetwork",
"../../ThirdParty/IOS/FBAudienceNetwork.embeddedframework.zip"
)
);
PublicAdditionalFrameworks.Add(
new Framework(
"FacebookAdapter",
"../../ThirdParty/IOS/FacebookAdapter.embeddedframework.zip"
)
);
PublicAdditionalFrameworks.Add(
new Framework(
"GoogleMobileAds",
"../../ThirdParty/IOS/GoogleMobileAds.embeddedframework.zip"
)
);
PublicAdditionalFrameworks.Add(
new Framework(
"GoogleAppMeasurement",
"../../ThirdParty/IOS/GoogleAppMeasurement.embeddedframework.zip"
)
);
PublicAdditionalFrameworks.Add(
new Framework(
"GoogleUtilities",
"../../ThirdParty/IOS/GoogleUtilities.embeddedframework.zip"
)
);
PublicAdditionalFrameworks.Add(
new Framework(
"nanopb",
"../../ThirdParty/IOS/nanopb.embeddedframework.zip"
)
);
PublicAdditionalFrameworks.Add(
new Framework(
"PromisesObjC",
"../../ThirdParty/IOS/PromisesObjC.embeddedframework.zip"
)
);
PublicAdditionalFrameworks.Add(
new Framework(
"UserMessagingPlatform",
"../../ThirdParty/IOS/UserMessagingPlatform.embeddedframework.zip"
)
);
PublicAdditionalFrameworks.Add(
new Framework(
"UnityAds",
"../../ThirdParty/IOS/UnityAds.embeddedframework.zip"
)
);
PublicAdditionalFrameworks.Add(
new Framework(
"UnityAdapter",
"../../ThirdParty/IOS/UnityAdapter.embeddedframework.zip"
)
);
}
}
public FMODStudio(TargetInfo Target)
{
bFasterWithoutUnity = true;
PublicIncludePaths.AddRange(
new string[] {
}
);
PrivateIncludePaths.AddRange(
new string[] {
"FMODStudio/Private",
"FMODStudio/Public/FMOD",
"FMODStudioOculus/Public",
}
);
PublicDependencyModuleNames.AddRange(
new string[]
{
"Core",
"CoreUObject",
"Engine",
"Projects"
}
);
PrivateDependencyModuleNames.AddRange(
new string[]
{
}
);
if (UEBuildConfiguration.bBuildEditor == true)
{
PrivateDependencyModuleNames.Add("AssetRegistry");
PrivateDependencyModuleNames.Add("UnrealEd");
}
DynamicallyLoadedModuleNames.AddRange(
new string[]
{
}
);
string configName = "";
if (Target.Configuration != UnrealTargetConfiguration.Shipping)
{
configName = "L";
Definitions.Add("FMODSTUDIO_LINK_LOGGING=1");
}
else
{
configName = "";
Definitions.Add("FMODSTUDIO_LINK_RELEASE=1");
}
string platformName = Target.Platform.ToString();
string platformMidName = "";
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);
string copyThirdPartyPath = "";
bool bAddRuntimeDependencies = true;
bool bAddDelayLoad = false;
bool bShortLinkNames = false;
bool bLinkFromBinaries = true;
switch (Target.Platform)
{
case UnrealTargetPlatform.Win32:
linkExtension = "_vc.lib";
dllExtension = ".dll";
bAddDelayLoad = true;
break;
case UnrealTargetPlatform.Win64:
platformMidName = "64";
linkExtension = "_vc.lib";
dllExtension = ".dll";
bAddDelayLoad = true;
break;
case UnrealTargetPlatform.Mac:
linkExtension = dllExtension = ".dylib";
libPrefix = "lib";
bLinkFromBinaries = false;
break;
case UnrealTargetPlatform.XboxOne:
linkExtension = "_vc.lib";
dllExtension = ".dll";
copyThirdPartyPath = "../XBoxOne"; // XBoxOne still doesn't seem to support plugins with .dlls
bAddDelayLoad = true;
break;
case UnrealTargetPlatform.PS4:
linkExtension = "_stub.a";
dllExtension = ".prx";
libPrefix = "lib";
bAddDelayLoad = true;
break;
case 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";
break;
case UnrealTargetPlatform.IOS:
linkExtension = "_iphoneos.a";
libPrefix = "lib";
bAddRuntimeDependencies = false;
break;
case UnrealTargetPlatform.Linux:
BasePath = System.IO.Path.Combine(BasePath, "x86_64");
linkExtension = ".so";
dllExtension = ".so";
libPrefix = "lib";
break;
case UnrealTargetPlatform.WinRT:
case UnrealTargetPlatform.WinRT_ARM:
case UnrealTargetPlatform.HTML5:
//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}{3}", libPrefix, configName, platformMidName, linkExtension);
string fmodStudioLibName = System.String.Format("{0}fmodstudio{1}{2}{3}", libPrefix, configName, platformMidName, linkExtension);
string fmodDllName = System.String.Format("{0}fmod{1}{2}{3}", libPrefix, configName, platformMidName, dllExtension);
string fmodStudioDllName = System.String.Format("{0}fmodstudio{1}{2}{3}", libPrefix, configName, platformMidName, 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}{1}", configName, platformMidName));
PublicAdditionalLibraries.Add(System.String.Format("fmodstudio{0}{1}", configName, platformMidName));
}
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(new RuntimeDependency(fmodDllPath));
RuntimeDependencies.Add(new RuntimeDependency(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(new RuntimeDependency(pluginPath));
}
}
if (copyThirdPartyPath.Length != 0)
{
string destPath = System.IO.Path.Combine(UEBuildConfiguration.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), BuildConfiguration.RelativeEnginePath);
System.Console.WriteLine("Adding {0}", RelAPLPath);
AdditionalPropertiesForReceipt.Add(new ReceiptProperty("AndroidPlugin", RelAPLPath));
foreach (string PluginName in System.IO.Directory.GetFiles(BasePath))
{
if (PluginName.EndsWith("_APL.xml", System.StringComparison.OrdinalIgnoreCase))
{
string RelPluginPath = Utils.MakePathRelativeTo(PluginName, BuildConfiguration.RelativeEnginePath);
System.Console.WriteLine("Adding {0}", RelPluginPath);
AdditionalPropertiesForReceipt.Add(new ReceiptProperty("AndroidPlugin", RelPluginPath));
}
}
}
}
public LandingANN(ReadOnlyTargetRules Target) : base(Target)
{
PCHUsage = PCHUsageMode.UseExplicitOrSharedPCHs;
PublicDependencyModuleNames.AddRange(new string[] { "Core", "CoreUObject", "Engine", "InputCore", "HeadMountedDisplay" });
}
public SuperTimeCommando(TargetInfo Target)
{
PublicDependencyModuleNames.AddRange(new string[] { "Core", "CoreUObject", "Engine", "InputCore", "HeadMountedDisplay", "ProceduralMeshComponent", "AIModule", "GameplayTasks" });
}
