public HarfBuzz(TargetInfo Target) { Type = ModuleType.External; // Can't be used without our dependencies if (!UEBuildConfiguration.bCompileFreeType || !UEBuildConfiguration.bCompileICU) { Definitions.Add("WITH_HARFBUZZ=0"); return; } string HarfBuzzVersion = "harfbuzz-1.2.4"; string HarfBuzzRootPath = UEBuildConfiguration.UEThirdPartySourceDirectory + "HarfBuzz/" + HarfBuzzVersion + "/"; // Includes PublicSystemIncludePaths.Add(HarfBuzzRootPath + "src" + "/"); string PlatformFolderName = Target.Platform.ToString(); string HarfBuzzLibPath = HarfBuzzRootPath + PlatformFolderName + "/"; if (Target.Platform == UnrealTargetPlatform.HTML5 && Target.Architecture == "-win32") { HarfBuzzLibPath = HarfBuzzRootPath + "Win32/"; } if ((Target.Platform == UnrealTargetPlatform.Win64) || (Target.Platform == UnrealTargetPlatform.Win32) || (Target.Platform == UnrealTargetPlatform.HTML5 && Target.Architecture == "-win32")) { Definitions.Add("WITH_HARFBUZZ=1"); string VSVersionFolderName = "VS" + WindowsPlatform.GetVisualStudioCompilerVersionName(); HarfBuzzLibPath += VSVersionFolderName + "/"; string BuildTypeFolderName = (Target.Configuration == UnrealTargetConfiguration.Debug && BuildConfiguration.bDebugBuildsActuallyUseDebugCRT) ? "Debug" : "RelWithDebInfo"; HarfBuzzLibPath += BuildTypeFolderName + "/"; PublicLibraryPaths.Add(HarfBuzzLibPath); PublicAdditionalLibraries.Add("harfbuzz.lib"); } else if (Target.Platform == UnrealTargetPlatform.HTML5) { string OpimizationSuffix = "_Oz"; // i.e. bCompileForSize if (!UEBuildConfiguration.bCompileForSize) { switch (Target.Configuration) { case UnrealTargetConfiguration.Development: OpimizationSuffix = "_O2"; break; case UnrealTargetConfiguration.Shipping: OpimizationSuffix = "_O3"; break; default: OpimizationSuffix = ""; break; } } PublicAdditionalLibraries.Add(HarfBuzzRootPath + "HTML5/libharfbuzz" + OpimizationSuffix + ".bc"); // PublicAdditionalLibraries.Add(HarfBuzzRootPath + "HTML5/libharfbuzz" + OpimizationSuffix + ".a"); } else if (Target.Platform == UnrealTargetPlatform.Mac || Target.Platform == UnrealTargetPlatform.IOS) { Definitions.Add("WITH_HARFBUZZ=1"); PublicAdditionalLibraries.Add(HarfBuzzLibPath + "libharfbuzz.a"); } else if (Target.Platform == UnrealTargetPlatform.PS4) { Definitions.Add("WITH_HARFBUZZ=1"); string BuildTypeFolderName = (Target.Configuration == UnrealTargetConfiguration.Debug && BuildConfiguration.bDebugBuildsActuallyUseDebugCRT) ? "Debug" : "Release"; HarfBuzzLibPath += BuildTypeFolderName + "/"; PublicLibraryPaths.Add(HarfBuzzLibPath); PublicAdditionalLibraries.Add("harfbuzz"); // Automatically transforms to libharfbuzz.a } else if (Target.Platform == UnrealTargetPlatform.XboxOne) { Definitions.Add("WITH_HARFBUZZ=1"); string BuildTypeFolderName = (Target.Configuration == UnrealTargetConfiguration.Debug && BuildConfiguration.bDebugBuildsActuallyUseDebugCRT) ? "Debug" : "Release"; HarfBuzzLibPath += "VS2015/" + BuildTypeFolderName + "/"; PublicLibraryPaths.Add(HarfBuzzLibPath); PublicAdditionalLibraries.Add("harfbuzz.lib"); } else if (Target.Platform == UnrealTargetPlatform.Android) { Definitions.Add("WITH_HARFBUZZ=1"); string BuildTypeFolderName = (Target.Configuration == UnrealTargetConfiguration.Debug && BuildConfiguration.bDebugBuildsActuallyUseDebugCRT) ? "Debug/" : "Release/"; PublicLibraryPaths.Add(HarfBuzzRootPath + "Android/ARMv7/" + BuildTypeFolderName); PublicLibraryPaths.Add(HarfBuzzRootPath + "Android/ARM64/" + BuildTypeFolderName); PublicLibraryPaths.Add(HarfBuzzRootPath + "Android/x86/" + BuildTypeFolderName); PublicLibraryPaths.Add(HarfBuzzRootPath + "Android/x64/" + BuildTypeFolderName); PublicAdditionalLibraries.Add("harfbuzz"); } else { Definitions.Add("WITH_HARFBUZZ=0"); } }
public SubstanceEngine(TargetInfo Target) { //Marked as an external module as we are not building any source code with this module Type = ModuleType.External; string BuildConfig = GetBuildConfig(Target); string PlatformConfig = GetPlatformConfig(Target); string SubstanceLibPath = ModuleDirectory + "/../../Libs/" + BuildConfig + "/" + PlatformConfig + "/"; Dictionary <SubstanceEngineType, string> EngineLibs = new Dictionary <SubstanceEngineType, string>(); List <string> StaticLibs = new List <string>(); //add linker libraries StaticLibs.Add("pfxlinkercommon"); StaticLibs.Add("algcompression"); StaticLibs.Add("tinyxml"); string LibExtension = ""; string LibPrefix = ""; if (Target.Platform == UnrealTargetPlatform.Win32 || Target.Platform == UnrealTargetPlatform.Win64) { LibExtension = ".lib"; StaticLibs.Add("substance_linker_static"); EngineLibs.Add(SubstanceEngineType.CPU, "substance_sse2_blend_static"); EngineLibs.Add(SubstanceEngineType.GPU, "substance_d3d11pc_blend_static"); } else if (Target.Platform == UnrealTargetPlatform.Mac || Target.Platform == UnrealTargetPlatform.Linux) { LibExtension = ".a"; LibPrefix = "lib"; StaticLibs.Add("substance_linker"); EngineLibs.Add(SubstanceEngineType.CPU, "substance_sse2_blend"); EngineLibs.Add(SubstanceEngineType.GPU, "substance_ogl3_blend"); } else if (Target.Platform == UnrealTargetPlatform.PS4) { LibExtension = ".a"; LibPrefix = "lib"; StaticLibs.Add("substance_linker"); EngineLibs.Add(SubstanceEngineType.CPU, "substance_avx_blend"); } else if (Target.Platform == UnrealTargetPlatform.XboxOne) { LibExtension = ".lib"; StaticLibs.Add("substance_linker"); EngineLibs.Add(SubstanceEngineType.CPU, "substance_avx_blend"); } else { throw new BuildException("Substance Plugin does not support platform " + Target.Platform.ToString()); } if (Target.Type == TargetRules.TargetType.Editor) { Definitions.Add("AIR_NO_DEFAULT_ENGINE"); Definitions.Add("SUBSTANCE_ENGINE_DYNAMIC"); StaticLibs.Add("substance_framework_editor"); if (BuildConfig == "Debug") { Definitions.Add("SUBSTANCE_ENGINE_DEBUG"); } } else { Definitions.Add("AIR_NO_DYNLOAD"); SubstanceEngineType type = GetEngineSuffix(); if (EngineLibs.ContainsKey(type)) { StaticLibs.Add(EngineLibs[type]); } else { StaticLibs.Add(EngineLibs[SubstanceEngineType.CPU]); } StaticLibs.Add("substance_framework"); //Linux GPU requires certain libraries added if (Target.Platform == UnrealTargetPlatform.Linux && type == SubstanceEngineType.GPU) { PublicAdditionalLibraries.AddRange(new string[] { "X11", "glut", "GLU", "GL" }); } } //add our static libs foreach (string staticlib in StaticLibs) { string libname = LibPrefix + staticlib + LibExtension; PublicAdditionalLibraries.Add(SubstanceLibPath + libname); } }
public SlateCore(TargetInfo Target) { PublicDependencyModuleNames.AddRange( new string[] { "Core", "CoreUObject", "InputCore", "Json", } ); PrivateIncludePaths.AddRange( new string[] { "Runtime/SlateCore/Private", "Runtime/SlateCore/Private/Animation", "Runtime/SlateCore/Private/Application", "Runtime/SlateCore/Private/Brushes", "Runtime/SlateCore/Private/Commands", "Runtime/SlateCore/Private/Fonts", "Runtime/SlateCore/Private/Input", "Runtime/SlateCore/Private/Layout", "Runtime/SlateCore/Private/Logging", "Runtime/SlateCore/Private/Rendering", "Runtime/SlateCore/Private/Sound", "Runtime/SlateCore/Private/Styling", "Runtime/SlateCore/Private/Textures", "Runtime/SlateCore/Private/Types", "Runtime/SlateCore/Private/Widgets", } ); if (Target.Type.Value != TargetRules.TargetType.Server) { if (UEBuildConfiguration.bCompileFreeType) { AddEngineThirdPartyPrivateStaticDependencies(Target, "FreeType2"); Definitions.Add("WITH_FREETYPE=1"); } else { Definitions.Add("WITH_FREETYPE=0"); } if (UEBuildConfiguration.bCompileICU) { AddEngineThirdPartyPrivateStaticDependencies(Target, "ICU"); } AddEngineThirdPartyPrivateStaticDependencies(Target, "HarfBuzz"); } else { Definitions.Add("WITH_FREETYPE=0"); Definitions.Add("WITH_HARFBUZZ=0"); } if ((Target.Platform == UnrealTargetPlatform.Win64) || (Target.Platform == UnrealTargetPlatform.Win32)) { AddEngineThirdPartyPrivateStaticDependencies(Target, "XInput"); } }
private FireRockMining() { HarvestResource[] res; HarvestVein[] veins; #region Mining for FireRock HarvestDefinition FireRock = m_FireRock = new HarvestDefinition(); // Resource banks are every 8x8 tiles FireRock.BankWidth = 8; FireRock.BankHeight = 8; // Every bank holds from 6 to 12 FireRock FireRock.MinTotal = 5; FireRock.MaxTotal = 8; // A resource bank will respawn its content every 10 to 20 minutes FireRock.MinRespawn = TimeSpan.FromMinutes(10.0); FireRock.MaxRespawn = TimeSpan.FromMinutes(20.0); // Skill checking is done on the Mining skill FireRock.Skill = SkillName.Mining; // Set the list of harvestable tiles FireRock.Tiles = m_LavaTiles; // Players must be within 2 tiles to harvest FireRock.MaxRange = 2; // One FireRock per harvest action FireRock.ConsumedPerHarvest = 1; FireRock.ConsumedPerFeluccaHarvest = 1; // The digging effect FireRock.EffectActions = new int[] { 11 }; FireRock.EffectSounds = new int[] { 0x125, 0x126 }; FireRock.EffectCounts = new int[] { 1 }; FireRock.EffectDelay = TimeSpan.FromSeconds(1.6); FireRock.EffectSoundDelay = TimeSpan.FromSeconds(0.9); FireRock.NoResourcesMessage = "There is no FireRock here to mine."; // There is no FireRock here to mine. FireRock.DoubleHarvestMessage = "There is no FireRock here to mine."; // There is no FireRock here to mine. FireRock.TimedOutOfRangeMessage = "You have moved too far away to continue mining."; // You have moved too far away to continue mining. FireRock.OutOfRangeMessage = "That is too far away."; // That is too far away. FireRock.FailMessage = "You dig for a while but fail to find any FireRock."; // You dig for a while but fail to find any FireRock. FireRock.PackFullMessage = "Your backpack can't hold the FireRock, and it is lost!"; // Your backpack can't hold the FireRock, and it is lost! FireRock.ToolBrokeMessage = 1044038; // You have worn out your tool! res = new HarvestResource[] { new HarvestResource(79.0, 59.0, 100.0, "You dig a SmallFireRock and put it in your backpack", typeof(SmallFireRock)), new HarvestResource(99.0, 79.0, 120.0, "You dig some CrystalineFire and put it in your backpack", typeof(CrystalineFire), typeof(FireRockElemental)), }; veins = new HarvestVein[] { new HarvestVein(80.7, 0.0, res[0], null), // SmallFireRock new HarvestVein(19.3, 0.5, res[1], res[0]), // CrystalineFire }; FireRock.Resources = res; FireRock.Veins = veins; Definitions.Add(FireRock); #endregion }
private Fishing() { HarvestResource[] res; HarvestVein[] veins; #region Fishing HarvestDefinition fish = new HarvestDefinition { // Resource banks are every 8x8 tiles BankWidth = 8, BankHeight = 8, // Every bank holds from 5 to 15 fish MinTotal = 5, MaxTotal = 15, // A resource bank will respawn its content every 10 to 20 minutes MinRespawn = TimeSpan.FromMinutes(10.0), MaxRespawn = TimeSpan.FromMinutes(20.0), // Skill checking is done on the Fishing skill Skill = SkillName.Fishing, // Set the list of harvestable tiles Tiles = m_WaterTiles, SpecialTiles = m_LavaTiles, RangedTiles = true, // Players must be within 4 tiles to harvest MaxRange = 4, // One fish per harvest action ConsumedPerHarvest = 1, ConsumedPerFeluccaHarvest = 1, // The fishing EffectActions = new int[] { 6 }, EffectSounds = new int[0], EffectCounts = new int[] { 1 }, EffectDelay = TimeSpan.Zero, EffectSoundDelay = TimeSpan.FromSeconds(8.0), NoResourcesMessage = 503172, // The fish don't seem to be biting here. FailMessage = 503171, // You fish a while, but fail to catch anything. TimedOutOfRangeMessage = 500976, // You need to be closer to the water to fish! OutOfRangeMessage = 500976, // You need to be closer to the water to fish! PackFullMessage = 503176, // You do not have room in your backpack for a fish. ToolBrokeMessage = 503174 // You broke your fishing pole. }; res = new HarvestResource[] { new HarvestResource(00.0, 00.0, 120.0, 1043297, typeof(Fish)) }; veins = new HarvestVein[] { new HarvestVein(100.0, 0.0, res[0], null) }; fish.Resources = res; fish.Veins = veins; fish.BonusResources = new BonusHarvestResource[] { new BonusHarvestResource(0, 97.0, null, null), //set to same chance as mining ml gems new BonusHarvestResource(80.0, 2.0, 1113764, typeof(DelicateScales)), new BonusHarvestResource(80.0, 1.0, 1072597, typeof(WhitePearl)) }; m_Definition = fish; Definitions.Add(fish); #endregion }
public D3D12RHI(TargetInfo Target) { PrivateIncludePaths.Add("Runtime/D3D12RHI/Private"); PrivateDependencyModuleNames.AddRange( new string[] { "Core", "Engine", "RHI", "RenderCore", "ShaderCore", "UtilityShaders", } ); if (Target.Configuration != UnrealTargetConfiguration.Shipping) { PrivateIncludePathModuleNames.AddRange(new string[] { "TaskGraph" }); } /////////////////////////////////////////////////////////////// // Platform agnostic defines /////////////////////////////////////////////////////////////// Definitions.Add("SUB_ALLOCATED_DEFAULT_ALLOCATIONS=1"); Definitions.Add("DEBUG_RESOURCE_STATES=0"); // DX12 doesn't support higher MSAA count Definitions.Add("DX_MAX_MSAA_COUNT=8"); // This is a value that should be tweaked to fit the app, lower numbers will have better performance Definitions.Add("MAX_SRVS=32"); Definitions.Add("MAX_CBS=8"); // This value controls how many root constant buffers can be used per shader stage in a root signature. // Note: Using root descriptors significantly increases the size of root signatures (each root descriptor is 2 DWORDs). Definitions.Add("MAX_ROOT_CBVS=MAX_CBS"); // PC uses a multiple root signatures that are optimized for a particular draw/dispatch. Definitions.Add("USE_STATIC_ROOT_SIGNATURE=0"); // How many residency packets can be in flight before the rendering thread // blocks for them to drain. Should be ~ NumBufferedFrames * AvgNumSubmissionsPerFrame i.e. // enough to ensure that the GPU is rarely blocked by residency work Definitions.Add("RESIDENCY_PIPELINE_DEPTH=6"); /////////////////////////////////////////////////////////////// // Platform specific defines /////////////////////////////////////////////////////////////// if (Target.Platform != UnrealTargetPlatform.Win64 && Target.Platform != UnrealTargetPlatform.XboxOne) { PrecompileForTargets = PrecompileTargetsType.None; } if (Target.Platform == UnrealTargetPlatform.Win64 || Target.Platform == UnrealTargetPlatform.Win32) { AddEngineThirdPartyPrivateStaticDependencies(Target, "DX12"); AddEngineThirdPartyPrivateStaticDependencies(Target, "DX11"); AddEngineThirdPartyPrivateStaticDependencies(Target, "NVAPI"); Definitions.Add("ENABLE_RESIDENCY_MANAGEMENT=1"); Definitions.Add("ASYNC_DEFERRED_DELETION=1"); Definitions.Add("PLATFORM_SUPPORTS_MGPU=1"); Definitions.Add("PIPELINE_STATE_FILE_LOCATION=FPaths::GameSavedDir()"); } else if (Target.Platform == UnrealTargetPlatform.XboxOne) { Definitions.Add("ENABLE_RESIDENCY_MANAGEMENT=0"); Definitions.Add("ASYNC_DEFERRED_DELETION=0"); Definitions.Add("PLATFORM_SUPPORTS_MGPU=0"); Definitions.Add("ASYNC_DEFERRED_DELETION=0"); // The number of sampler descriptors with the maximum value of 2048 // If the heap type is unbounded the number could be increased to avoid rollovers. Definitions.Add("ENABLE_UNBOUNDED_SAMPLER_DESCRIPTORS=0"); Definitions.Add("NUM_SAMPLER_DESCRIPTORS=D3D12_MAX_SHADER_VISIBLE_SAMPLER_HEAP_SIZE"); // Xbox doesn't have DXGI but common code needs this defined for headers Definitions.Add("DXGI_QUERY_VIDEO_MEMORY_INFO=int"); Definitions.Add("PIPELINE_STATE_FILE_LOCATION=FPaths::GameContentDir()"); } }
public IntelTBB(TargetInfo Target) { Type = ModuleType.External; if ((Target.Platform == UnrealTargetPlatform.Win64) || (Target.Platform == UnrealTargetPlatform.Win32)) { string IntelTBBPath = UEBuildConfiguration.UEThirdPartySourceDirectory + "IntelTBB/"; switch (WindowsPlatform.Compiler) { case WindowsCompiler.VisualStudio2017: case WindowsCompiler.VisualStudio2015: IntelTBBPath += "IntelTBB-4.4u3/"; break; case WindowsCompiler.VisualStudio2013: IntelTBBPath += "IntelTBB-4.0/"; break; } PublicSystemIncludePaths.Add(IntelTBBPath + "Include"); if (Target.Platform == UnrealTargetPlatform.Win64) { if (WindowsPlatform.Compiler == WindowsCompiler.VisualStudio2015 || WindowsPlatform.Compiler == WindowsCompiler.VisualStudio2017) { PublicLibraryPaths.Add(IntelTBBPath + "lib/Win64/vc14"); } else if (WindowsPlatform.Compiler == WindowsCompiler.VisualStudio2013) { PublicLibraryPaths.Add(IntelTBBPath + "lib/Win64/vc12"); } } else if (Target.Platform == UnrealTargetPlatform.Win32) { if (WindowsPlatform.Compiler == WindowsCompiler.VisualStudio2015 || WindowsPlatform.Compiler == WindowsCompiler.VisualStudio2017) { PublicLibraryPaths.Add(IntelTBBPath + "lib/Win32/vc14"); } else if (WindowsPlatform.Compiler == WindowsCompiler.VisualStudio2013) { PublicLibraryPaths.Add(IntelTBBPath + "lib/Win32/vc12"); } } // Disable the #pragma comment(lib, ...) used by default in MallocTBB... // We want to explicitly include the library. Definitions.Add("__TBBMALLOC_BUILD=1"); string LibName = "tbbmalloc"; if (Target.Configuration == UnrealTargetConfiguration.Debug && BuildConfiguration.bDebugBuildsActuallyUseDebugCRT) { LibName += "_debug"; } LibName += ".lib"; PublicAdditionalLibraries.Add(LibName); } else if (Target.Platform == UnrealTargetPlatform.Mac) { PublicSystemIncludePaths.AddRange( new string[] { UEBuildConfiguration.UEThirdPartySourceDirectory + "IntelTBB/IntelTBB-4.0/include", } ); PublicAdditionalLibraries.AddRange( new string[] { UEBuildConfiguration.UEThirdPartySourceDirectory + "IntelTBB/IntelTBB-4.0/lib/Mac/libtbb.a", UEBuildConfiguration.UEThirdPartySourceDirectory + "IntelTBB/IntelTBB-4.0/lib/Mac/libtbbmalloc.a", } ); } }
public UnrealEd(ReadOnlyTargetRules Target) : base(Target) { PrivatePCHHeaderFile = "Private/UnrealEdPrivatePCH.h"; SharedPCHHeaderFile = "Public/UnrealEdSharedPCH.h"; PrivateIncludePaths.AddRange( new string[] { "Editor/UnrealEd/Private", "Editor/UnrealEd/Private/Settings", "Editor/PackagesDialog/Public", "Developer/DerivedDataCache/Public", "Developer/TargetPlatform/Public", } ); PrivateIncludePathModuleNames.AddRange( new string[] { "AssetRegistry", "AssetTools", "BehaviorTreeEditor", "ClassViewer", "ContentBrowser", "CrashTracker", "DerivedDataCache", "DesktopPlatform", "EnvironmentQueryEditor", "GameProjectGeneration", "ProjectTargetPlatformEditor", "ImageWrapper", "MainFrame", "MaterialEditor", "MergeActors", "MeshUtilities", "Messaging", "MovieSceneCapture", "NiagaraEditor", "PlacementMode", "Settings", "SettingsEditor", "SuperSearch", "AudioEditor", "ViewportSnapping", "SourceCodeAccess", "ReferenceViewer", "IntroTutorials", "OutputLog", "Landscape", "Niagara", "SizeMap", "LocalizationService", "HierarchicalLODUtilities", "MessagingRpc", "PortalRpc", "PortalServices", "BlueprintNativeCodeGen", "ViewportInteraction", "VREditor", "Persona", "ClothingSystemEditorInterface", } ); PublicDependencyModuleNames.AddRange( new string[] { "BspMode", "Core", "CoreUObject", "DirectoryWatcher", "Documentation", "Engine", "Json", "Projects", "SandboxFile", "Slate", "SlateCore", "EditorStyle", "SourceControl", "UnrealEdMessages", "AIModule", "GameplayDebugger", "BlueprintGraph", "Http", "UnrealAudio", "FunctionalTesting", "AutomationController", "Localization", "AudioEditor", } ); PrivateDependencyModuleNames.AddRange( new string[] { "LevelSequence", "AnimGraph", "AppFramework", "BlueprintGraph", "CinematicCamera", "DesktopPlatform", "EditorStyle", "EngineSettings", "InputCore", "InputBindingEditor", "LauncherServices", "MaterialEditor", "MessageLog", "NetworkFileSystem", "PakFile", "PropertyEditor", "Projects", "RawMesh", "RenderCore", "RHI", "ShaderCore", "Sockets", "SourceControlWindows", "StatsViewer", "SwarmInterface", "TargetPlatform", "TargetDeviceServices", "EditorWidgets", "GraphEditor", "Kismet", "InternationalizationSettings", "JsonUtilities", "Landscape", "HeadMountedDisplay", "MeshPaint", "MeshPaintMode", "Foliage", "VectorVM", "TreeMap", "MaterialUtilities", "Localization", "LocalizationService", "AddContentDialog", "GameProjectGeneration", "HierarchicalLODUtilities", "Analytics", "AnalyticsET", "PluginWarden", "PixelInspectorModule", "MovieScene", "MovieSceneTracks", "ViewportInteraction", "VREditor", "ClothingSystemEditor", "ClothingSystemRuntime", "ClothingSystemRuntimeInterface", } ); DynamicallyLoadedModuleNames.AddRange( new string[] { "CrashTracker", "FontEditor", "StaticMeshEditor", "TextureEditor", "Cascade", "UMGEditor", "Matinee", "AssetRegistry", "AssetTools", "ClassViewer", "CollectionManager", "ContentBrowser", "CurveTableEditor", "DataTableEditor", "DestructibleMeshEditor", "EditorSettingsViewer", "LandscapeEditor", "KismetCompiler", "DetailCustomizations", "ComponentVisualizers", "MainFrame", "LevelEditor", "PackagesDialog", "Persona", "PhAT", "ProjectLauncher", "DeviceManager", "SettingsEditor", "SessionFrontend", "Sequencer", "StringTableEditor", "SuperSearch", "GeometryMode", "TextureAlignMode", "FoliageEdit", "PackageDependencyInfo", "ImageWrapper", "Blutility", "IntroTutorials", "WorkspaceMenuStructure", "PlacementMode", "NiagaraEditor", "MeshUtilities", "MergeActors", "ProjectSettingsViewer", "ProjectTargetPlatformEditor", "PListEditor", "BehaviorTreeEditor", "EnvironmentQueryEditor", "ViewportSnapping", "UserFeedback", "GameplayTasksEditor", "UndoHistory", "SourceCodeAccess", "ReferenceViewer", "EditorLiveStreaming", "HotReload", "IOSPlatformEditor", "HTML5PlatformEditor", "SizeMap", "PortalProxies", "PortalServices", "GeometryCacheEd", "BlueprintNativeCodeGen", "AnimationModifiers", "ClothPainter", } ); if (Target.Platform == UnrealTargetPlatform.Win64 || Target.Platform == UnrealTargetPlatform.Win32 || Target.Platform == UnrealTargetPlatform.Mac || Target.Platform == UnrealTargetPlatform.Linux) { DynamicallyLoadedModuleNames.Add("AndroidPlatformEditor"); } CircularlyReferencedDependentModules.AddRange( new string[] { "GraphEditor", "Kismet", "AudioEditor", "ViewportInteraction", "VREditor" } ); // Add include directory for Lightmass PublicIncludePaths.Add("Programs/UnrealLightmass/Public"); PublicIncludePathModuleNames.AddRange( new string[] { "UserFeedback", "CollectionManager", "BlueprintGraph", "AddContentDialog", "MeshUtilities" } ); if ((Target.Platform == UnrealTargetPlatform.Win64) || (Target.Platform == UnrealTargetPlatform.Win32)) { PublicDependencyModuleNames.Add("XAudio2"); PublicDependencyModuleNames.Add("AudioMixerXAudio2"); PublicDependencyModuleNames.Add("UnrealAudioXAudio2"); AddEngineThirdPartyPrivateStaticDependencies(Target, "UEOgg", "Vorbis", "VorbisFile", "DX11Audio" ); } if (Target.Platform == UnrealTargetPlatform.HTML5) { PublicDependencyModuleNames.Add("ALAudio"); } AddEngineThirdPartyPrivateStaticDependencies(Target, "HACD", "VHACD", "FBX", "FreeType2" ); SetupModulePhysXAPEXSupport(Target); if (UEBuildConfiguration.bCompileRecast) { PrivateDependencyModuleNames.Add("Navmesh"); Definitions.Add("WITH_RECAST=1"); } else { Definitions.Add("WITH_RECAST=0"); } }
public UnrealEnginePython(TargetInfo Target) { System.Console.WriteLine("Using Python at: " + PythonHome); 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", // ... add other public dependencies that you statically link with here ... } ); PrivateDependencyModuleNames.AddRange( new string[] { "CoreUObject", "Engine", "InputCore", "Slate", "SlateCore", "MovieScene", "LevelSequence", // ... add private dependencies that you statically link with here ... } ); DynamicallyLoadedModuleNames.AddRange( new string[] { // ... add any modules that your module loads dynamically here ... } ); if (UEBuildConfiguration.bBuildEditor) { PrivateDependencyModuleNames.AddRange(new string[] { "UnrealEd" }); } if ((Target.Platform == UnrealTargetPlatform.Win64) || (Target.Platform == UnrealTargetPlatform.Win32)) { PublicIncludePaths.Add(PythonHome); PublicAdditionalLibraries.Add(Path.Combine(PythonHome, "libs", "python35.lib")); } else if (Target.Platform == UnrealTargetPlatform.Mac) { string mac_python = "/Library/Frameworks/Python.framework/Versions/3.5/"; PublicIncludePaths.Add(Path.Combine(mac_python, "include")); PublicAdditionalLibraries.Add(Path.Combine(mac_python, "lib", "libpython3.5m.dylib")); Definitions.Add(string.Format("UNREAL_ENGINE_PYTHON_ON_MAC=1")); } }
public Facebook(ReadOnlyTargetRules Target) : base(Target) { Type = ModuleType.External; Definitions.Add("WITH_FACEBOOK=1"); // Additional Frameworks and Libraries for Android found in OnlineSubsystemFacebook_UPL.xml if (Target.Platform == UnrealTargetPlatform.IOS) { Definitions.Add("UE4_FACEBOOK_VER=4.18"); // These are iOS system libraries that Facebook depends on (FBAudienceNetwork, FBNotifications) PublicFrameworks.AddRange( new string[] { "ImageIO" }); // More dependencies for Facebook (FBAudienceNetwork, FBNotifications) PublicAdditionalLibraries.AddRange( new string[] { "xml2" }); PublicAdditionalFrameworks.Add( new UEBuildFramework( "AccountKit", "IOS/FacebookSDK/AccountKit.embeddedframework.zip", "AccountKit.framework/AccountKitAdditionalStrings.bundle" ) ); PublicAdditionalFrameworks.Add( new UEBuildFramework( "AccountKit", "IOS/FacebookSDK/AccountKit.embeddedframework.zip", "AccountKit.framework/AccountKitStrings.bundle" ) ); PublicAdditionalFrameworks.Add( new UEBuildFramework( "Bolts", "IOS/FacebookSDK/Bolts.embeddedframework.zip" ) ); // Add the FBAudienceNetwork framework PublicAdditionalFrameworks.Add( new UEBuildFramework( "FBAudienceNetwork", "IOS/FacebookSDK/FBAudienceNetwork.embeddedframework.zip" ) ); // Access to Facebook notifications PublicAdditionalFrameworks.Add( new UEBuildFramework( "FBNotifications", "IOS/FacebookSDK/FBNotifications.embeddedframework.zip" ) ); // Access to Facebook core PublicAdditionalFrameworks.Add( new UEBuildFramework( "FBSDKCoreKit", "IOS/FacebookSDK/FBSDKCoreKit.embeddedframework.zip", "FBSDKCoreKit.framework/Resources/FacebookSDKStrings.bundle" ) ); // Access to Facebook login PublicAdditionalFrameworks.Add( new UEBuildFramework( "FBSDKLoginKit", "IOS/FacebookSDK/FBSDKLoginKit.embeddedframework.zip" ) ); // Access to Facebook messenger sharing PublicAdditionalFrameworks.Add( new UEBuildFramework( "FBSDKMessengerShareKit", "IOS/FacebookSDK/FBSDKMessengerShareKit.embeddedframework.zip" ) ); // Access to Facebook sharing PublicAdditionalFrameworks.Add( new UEBuildFramework( "FBSDKShareKit", "IOS/FacebookSDK/FBSDKShareKit.embeddedframework.zip" ) ); } }
private bool LoadV8(ReadOnlyTargetRules Target) { int[] v8_version = GetV8Version(); bool ShouldLink_libsampler = !(v8_version[0] == 5 && v8_version[1] < 3); if ((Target.Platform == UnrealTargetPlatform.Win64) || (Target.Platform == UnrealTargetPlatform.Win32)) { string LibrariesPath = Path.Combine(ThirdPartyPath, "v8", "lib"); if (Target.Platform == UnrealTargetPlatform.Win64) { LibrariesPath = Path.Combine(LibrariesPath, "Win64"); } else { LibrariesPath = Path.Combine(LibrariesPath, "Win32"); } if (Target.Configuration == UnrealTargetConfiguration.Debug) { LibrariesPath = Path.Combine(LibrariesPath, "Debug"); } else { LibrariesPath = Path.Combine(LibrariesPath, "Release"); } PublicAdditionalLibraries.Add(Path.Combine(LibrariesPath, "v8_base_0.lib")); PublicAdditionalLibraries.Add(Path.Combine(LibrariesPath, "v8_base_1.lib")); PublicAdditionalLibraries.Add(Path.Combine(LibrariesPath, "v8_base_2.lib")); PublicAdditionalLibraries.Add(Path.Combine(LibrariesPath, "v8_base_3.lib")); PublicAdditionalLibraries.Add(Path.Combine(LibrariesPath, "v8_libbase.lib")); PublicAdditionalLibraries.Add(Path.Combine(LibrariesPath, "v8_libplatform.lib")); PublicAdditionalLibraries.Add(Path.Combine(LibrariesPath, "v8_nosnapshot.lib")); if (ShouldLink_libsampler) { PublicAdditionalLibraries.Add(Path.Combine(LibrariesPath, "v8_libsampler.lib")); } Definitions.Add(string.Format("WITH_V8=1")); return(true); } else if (Target.Platform == UnrealTargetPlatform.Android) { string LibrariesPath = Path.Combine(ThirdPartyPath, "v8", "lib", "Android"); PublicLibraryPaths.Add(Path.Combine(LibrariesPath, "ARMv7")); PublicLibraryPaths.Add(Path.Combine(LibrariesPath, "ARM64")); PublicLibraryPaths.Add(Path.Combine(LibrariesPath, "x86")); PublicLibraryPaths.Add(Path.Combine(LibrariesPath, "x64")); PublicAdditionalLibraries.Add("v8_base"); PublicAdditionalLibraries.Add("v8_libbase"); PublicAdditionalLibraries.Add("v8_libplatform"); PublicAdditionalLibraries.Add("v8_nosnapshot"); if (ShouldLink_libsampler) { PublicAdditionalLibraries.Add("v8_libsampler"); } Definitions.Add(string.Format("WITH_V8=1")); return(true); } else if (Target.Platform == UnrealTargetPlatform.Linux) { string LibrariesPath = Path.Combine(ThirdPartyPath, "v8", "lib", "Linux"); PublicLibraryPaths.Add(Path.Combine(LibrariesPath, "x64")); PublicAdditionalLibraries.Add("v8_base"); PublicAdditionalLibraries.Add("v8_libbase"); PublicAdditionalLibraries.Add("v8_libplatform"); PublicAdditionalLibraries.Add("v8_nosnapshot"); if (ShouldLink_libsampler) { PublicAdditionalLibraries.Add("v8_libsampler"); } Definitions.Add(string.Format("WITH_V8=1")); return(true); } else if (Target.Platform == UnrealTargetPlatform.Mac) { string LibrariesPath = Path.Combine(ThirdPartyPath, "v8", "lib", "Mac", "x64"); PublicLibraryPaths.Add(LibrariesPath); PublicAdditionalLibraries.Add(Path.Combine(LibrariesPath, "libv8_base.a")); PublicAdditionalLibraries.Add(Path.Combine(LibrariesPath, "libv8_libbase.a")); PublicAdditionalLibraries.Add(Path.Combine(LibrariesPath, "libv8_libplatform.a")); PublicAdditionalLibraries.Add(Path.Combine(LibrariesPath, "libv8_nosnapshot.a")); if (ShouldLink_libsampler) { PublicAdditionalLibraries.Add(Path.Combine(LibrariesPath, "libv8_libsampler.a")); } Definitions.Add(string.Format("WITH_V8=1")); return(true); } Definitions.Add(string.Format("WITH_V8=0")); return(false); }
public libcurl(TargetInfo Target) { Type = ModuleType.External; Definitions.Add("WITH_LIBCURL=1"); string NewLibCurlPath = UEBuildConfiguration.UEThirdPartySourceDirectory + "libcurl/7_48_0/"; string LibCurlPath = UEBuildConfiguration.UEThirdPartySourceDirectory + "libcurl/curl-7.47.1/"; // TODO: latest recompile for consoles and mobile platforms string OldLibCurlPath = UEBuildConfiguration.UEThirdPartySourceDirectory + "libcurl/"; if (Target.Platform == UnrealTargetPlatform.Linux) { string platform = "/Linux/" + Target.Architecture; string IncludePath = NewLibCurlPath + "include" + platform; string LibraryPath = NewLibCurlPath + "lib" + platform; PublicIncludePaths.Add(IncludePath); PublicLibraryPaths.Add(LibraryPath); PublicAdditionalLibraries.Add(LibraryPath + "/libcurl.a"); PrivateDependencyModuleNames.Add("SSL"); } else if (Target.Platform == UnrealTargetPlatform.Android) { // toolchain will filter properly PublicIncludePaths.Add(OldLibCurlPath + "include/Android/ARMv7"); PublicLibraryPaths.Add(OldLibCurlPath + "lib/Android/ARMv7"); PublicIncludePaths.Add(OldLibCurlPath + "include/Android/ARM64"); PublicLibraryPaths.Add(OldLibCurlPath + "lib/Android/ARM64"); PublicIncludePaths.Add(OldLibCurlPath + "include/Android/x86"); PublicLibraryPaths.Add(OldLibCurlPath + "lib/Android/x86"); PublicIncludePaths.Add(OldLibCurlPath + "include/Android/x64"); PublicLibraryPaths.Add(OldLibCurlPath + "lib/Android/x64"); PublicAdditionalLibraries.Add("curl"); // PublicAdditionalLibraries.Add("crypto"); // PublicAdditionalLibraries.Add("ssl"); // PublicAdditionalLibraries.Add("dl"); } else if (Target.Platform == UnrealTargetPlatform.Mac) { string PlatformSubdir = "/Mac/"; PublicIncludePaths.Add(LibCurlPath + "include" + PlatformSubdir); // OSX needs full path PublicAdditionalLibraries.Add(LibCurlPath + "lib" + PlatformSubdir + "libcurl.a"); } else if (Target.Platform == UnrealTargetPlatform.Win32 || Target.Platform == UnrealTargetPlatform.Win64 || (Target.Platform == UnrealTargetPlatform.HTML5 && Target.Architecture == "-win32")) { string PlatformSubdir = (Target.Platform == UnrealTargetPlatform.HTML5) ? "Win32" : Target.Platform.ToString(); PublicIncludePaths.Add(LibCurlPath + "/include/" + PlatformSubdir + "/VS" + WindowsPlatform.GetVisualStudioCompilerVersionName()); PublicLibraryPaths.Add(LibCurlPath + "/lib/" + PlatformSubdir + "/VS" + WindowsPlatform.GetVisualStudioCompilerVersionName()); PublicAdditionalLibraries.Add("libcurl_a.lib"); Definitions.Add("CURL_STATICLIB=1"); } }
public GoogleTest(ReadOnlyTargetRules Target) : base(Target) { Type = ModuleType.External; string RootPath = Target.UEThirdPartySourceDirectory + "GoogleTest/"; string DefaultConfiguration = "MinSizeRel"; // Includes PublicSystemIncludePaths.Add(RootPath + "include/"); // Libraries string PartialLibraryPath = "lib/" + Target.Platform.ToString() + "/"; string LibraryPath = RootPath; if (Target.Platform == UnrealTargetPlatform.Win64 || Target.Platform == UnrealTargetPlatform.Win32) { PartialLibraryPath += "VS" + Target.WindowsPlatform.GetVisualStudioCompilerVersionName(); if (Target.Configuration == UnrealTargetConfiguration.Debug && Target.bDebugBuildsActuallyUseDebugCRT) { PartialLibraryPath += "/Debug"; } else { PartialLibraryPath += "/" + DefaultConfiguration; } //if (!Target.IsMonolithic) //{ // PartialLibraryPath += "_Shared"; //} PartialLibraryPath += "/"; LibraryPath += PartialLibraryPath; //i.e. Engine\Source\ThirdParty\GoogleTest\lib\Win64\VS2013\MinSizeRel_Shared\ // I was unable to get non-monolithic windows builds working without crashing within the // time box I was given for the integration. The workaround is to ensure that all tests // are included in the same dll when building monolithic, otherwise error messages // will not be routed properly. // We should re-investigate this integration problem in the future, as more teams want to // adopt usage of the library //if (!Target.IsMonolithic) //{ // PublicAdditionalLibraries.Add("gmock_main.lib"); // RuntimeDependencies.Add(new RuntimeDependency("$(EngineDir)/Binaries/ThirdParty/GoogleTest/" + PartialLibraryPath + "gmock_main.dll")); //} //else //{ PublicAdditionalLibraries.Add("gtest.lib"); PublicAdditionalLibraries.Add("gmock.lib"); PublicAdditionalLibraries.Add("gmock_main.lib"); //} } else if (Target.Platform == UnrealTargetPlatform.Mac) { if (Target.LinkType == TargetLinkType.Monolithic) { PartialLibraryPath += DefaultConfiguration + "/"; LibraryPath += PartialLibraryPath; PublicAdditionalLibraries.Add(LibraryPath + "libgtest.a"); PublicAdditionalLibraries.Add(LibraryPath + "libgmock.a"); PublicAdditionalLibraries.Add(LibraryPath + "libgmock_main.a"); } else { PartialLibraryPath += DefaultConfiguration + "_Shared/"; LibraryPath += PartialLibraryPath; PublicAdditionalLibraries.Add(LibraryPath + "libgmock_main.dylib"); } } PublicLibraryPaths.Add(LibraryPath); // The including module will also need these enabled Definitions.Add("WITH_GOOGLE_MOCK=1"); Definitions.Add("WITH_GOOGLE_TEST=1"); Definitions.Add("GTEST_HAS_POSIX_RE=0"); if (Target.LinkType != TargetLinkType.Monolithic) { //Definitions.Add("GTEST_LINKED_AS_SHARED_LIBRARY=1"); } }
private Lumberjacking() { HarvestResource[] res; HarvestVein[] veins; #region Lumberjacking HarvestDefinition lumber = new HarvestDefinition(); // Resource banks are every 4x3 tiles lumber.BankWidth = 4; lumber.BankHeight = 3; // Every bank holds from 20 to 45 logs lumber.MinTotal = 20; lumber.MaxTotal = 45; // A resource bank will respawn its content every 20 to 30 minutes lumber.MinRespawn = TimeSpan.FromMinutes(20.0); lumber.MaxRespawn = TimeSpan.FromMinutes(30.0); // Skill checking is done on the Lumberjacking skill lumber.Skill = SkillName.Lumberjacking; // Set the list of harvestable tiles lumber.Tiles = m_TreeTiles; // Players must be within 2 tiles to harvest lumber.MaxRange = 2; // Ten logs per harvest action lumber.ConsumedPerHarvest = 10; lumber.ConsumedPerFeluccaHarvest = 20; // The chopping effect lumber.EffectActions = new int[] { 13 }; lumber.EffectSounds = new int[] { 0x13E }; lumber.EffectCounts = (Core.AOS ? new int[] { 1 } : new int[] { 1, 2, 2, 2, 3 }); lumber.EffectDelay = TimeSpan.FromSeconds(1.6); lumber.EffectSoundDelay = TimeSpan.FromSeconds(0.9); lumber.AFKChance = ((1.6 * 2 + 0.9) / 60) / 30; //Approx once every 30 minutes. lumber.NoResourcesMessage = 500493; // There's not enough wood here to harvest. lumber.FailMessage = 500495; // You hack at the tree for a while, but fail to produce any useable wood. lumber.OutOfRangeMessage = 500446; // That is too far away. lumber.PackFullMessage = 500497; // You can't place any wood into your backpack! lumber.ToolBrokeMessage = 500499; // You broke your axe. if (Core.ML) { res = new HarvestResource[] { new HarvestResource(00.0, 00.0, 100.0, 1072540, typeof(Log)), new HarvestResource(65.0, 25.0, 105.0, 1072541, typeof(OakLog)), new HarvestResource(80.0, 40.0, 120.0, 1072542, typeof(AshLog)), new HarvestResource(95.0, 55.0, 135.0, 1072543, typeof(YewLog)), new HarvestResource(100.0, 60.0, 140.0, 1072544, typeof(HeartwoodLog)), new HarvestResource(100.0, 60.0, 140.0, 1072545, typeof(BloodwoodLog)), new HarvestResource(100.0, 60.0, 140.0, 1072546, typeof(FrostwoodLog)), }; veins = new HarvestVein[] { new HarvestVein(49.0, 0.0, res[0], null), // Ordinary Logs new HarvestVein(30.0, 0.5, res[1], res[0]), // Oak new HarvestVein(10.0, 0.5, res[2], res[0]), // Ash new HarvestVein(05.0, 0.5, res[3], res[0]), // Yew new HarvestVein(03.0, 0.5, res[4], res[0]), // Heartwood new HarvestVein(02.0, 0.5, res[5], res[0]), // Bloodwood new HarvestVein(01.0, 0.5, res[6], res[0]), // Frostwood }; lumber.BonusResources = new BonusHarvestResource[] { new BonusHarvestResource(0, 83.9, null, null), //Nothing new BonusHarvestResource(100, 10.0, 1072548, typeof(BarkFragment)), new BonusHarvestResource(100, 03.0, 1072550, typeof(LuminescentFungi)), new BonusHarvestResource(100, 02.0, 1072547, typeof(SwitchItem)), new BonusHarvestResource(100, 01.0, 1072549, typeof(ParasiticPlant)), new BonusHarvestResource(100, 00.1, 1072551, typeof(BrilliantAmber)) }; } else { res = new HarvestResource[] { new HarvestResource(00.0, 00.0, 100.0, 500498, typeof(Log)) }; veins = new HarvestVein[] { new HarvestVein(100.0, 0.0, res[0], null) }; } lumber.Resources = res; lumber.Veins = veins; lumber.RaceBonus = Core.ML; lumber.RandomizeVeins = Core.ML; m_Definition = lumber; Definitions.Add(lumber); #endregion }
public HoudiniEngineEditor(TargetInfo Target) { PCHUsage = PCHUsageMode.UseSharedPCHs; bool bIsRelease = true; string HFSPath = ""; string HoudiniVersion = "16.0.543"; // 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/" + 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" } ); // 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 ... } ); }
private Fishing() { HarvestResource[] res; HarvestVein[] veins; #region Fishing HarvestDefinition fish = new HarvestDefinition(); // Resource banks are every 8x8 tiles fish.BankWidth = 8; fish.BankHeight = 8; // Every bank holds from 5 to 15 fish fish.MinTotal = 5; fish.MaxTotal = 15; // A resource bank will respawn its content every 10 to 20 minutes fish.MinRespawn = TimeSpan.FromMinutes(10.0); fish.MaxRespawn = TimeSpan.FromMinutes(20.0); // Skill checking is done on the Fishing skill fish.Skill = SkillName.Fishing; // Set the list of harvestable tiles fish.Tiles = m_WaterTiles; fish.RangedTiles = true; // Players must be within 4 tiles to harvest fish.MaxRange = 4; // One fish per harvest action fish.ConsumedPerHarvest = 1; fish.ConsumedPerFeluccaHarvest = 1; // The fishing fish.EffectActions = new int[] { 12 }; fish.EffectSounds = new int[0]; fish.EffectCounts = new int[] { 1 }; fish.EffectDelay = TimeSpan.Zero; fish.EffectSoundDelay = TimeSpan.FromSeconds(8.0); fish.NoResourcesMessage = 503172; // The fish don't seem to be biting here. fish.FailMessage = 503171; // You fish a while, but fail to catch anything. fish.TimedOutOfRangeMessage = 500976; // You need to be closer to the water to fish! fish.OutOfRangeMessage = 500976; // You need to be closer to the water to fish! fish.PackFullMessage = 503176; // You do not have room in your backpack for a fish. fish.ToolBrokeMessage = 503174; // You broke your fishing pole. res = new HarvestResource[] { new HarvestResource(00.0, 00.0, 100.0, 1043297, typeof(Fish)) }; veins = new HarvestVein[] { new HarvestVein(100.0, 0.0, res[0], null) }; fish.Resources = res; fish.Veins = veins; if (Core.ML) { fish.BonusResources = new BonusHarvestResource[] { new BonusHarvestResource(0, 99.4, null, null), //set to same chance as mining ml gems new BonusHarvestResource(80.0, .6, 1072597, typeof(WhitePearl)) }; } m_Definition = fish; Definitions.Add(fish); #endregion }
public HTTP(ReadOnlyTargetRules Target) : base(Target) { Definitions.Add("HTTP_PACKAGE=1"); PrivateIncludePaths.AddRange( new string[] { "Runtime/Online/HTTP/Private", } ); PrivateDependencyModuleNames.AddRange( new string[] { "Core", "Sockets" } ); bool bWithCurl = false; if (Target.Platform == UnrealTargetPlatform.Win32 || Target.Platform == UnrealTargetPlatform.Win64) { AddEngineThirdPartyPrivateStaticDependencies(Target, "WinInet"); AddEngineThirdPartyPrivateStaticDependencies(Target, "WinHttp"); AddEngineThirdPartyPrivateStaticDependencies(Target, "libcurl"); bWithCurl = true; PrivateDependencyModuleNames.Add("SSL"); } else if (Target.Platform == UnrealTargetPlatform.Linux || Target.Platform == UnrealTargetPlatform.Android || Target.Platform == UnrealTargetPlatform.Switch) { AddEngineThirdPartyPrivateStaticDependencies(Target, "libcurl"); PrivateDependencyModuleNames.Add("SSL"); bWithCurl = true; } else { Definitions.Add("WITH_SSL=0"); Definitions.Add("WITH_LIBCURL=0"); } if (bWithCurl) { Definitions.Add("CURL_ENABLE_DEBUG_CALLBACK=1"); if (Target.Configuration != UnrealTargetConfiguration.Shipping) { Definitions.Add("CURL_ENABLE_NO_TIMEOUTS_OPTION=1"); } } if (Target.Platform == UnrealTargetPlatform.HTML5) { PrivateDependencyModuleNames.Add("HTML5JS"); } if (Target.Platform == UnrealTargetPlatform.IOS || Target.Platform == UnrealTargetPlatform.TVOS || Target.Platform == UnrealTargetPlatform.Mac) { PublicFrameworks.Add("Security"); } }
private Mining() { HarvestResource[] res; HarvestVein[] veins; #region Mining for ore and stone HarvestDefinition oreAndStone = m_OreAndStone = new HarvestDefinition(); // Resource banks are every 8x8 tiles oreAndStone.BankWidth = 8; oreAndStone.BankHeight = 8; oreAndStone.MinTotal = 5; oreAndStone.MaxTotal = 15; oreAndStone.MinRespawn = TimeSpan.FromMinutes(10.0); oreAndStone.MaxRespawn = TimeSpan.FromMinutes(20.0); // Skill checking is done on the Mining skill oreAndStone.Skill = SkillName.Mining; // Set the list of harvestable tiles oreAndStone.Tiles = m_MountainAndCaveTiles; // Players must be within 2 tiles to harvest oreAndStone.MaxRange = 4; // One ore per harvest action oreAndStone.ConsumedPerHarvest = 1; oreAndStone.ConsumedPerFeluccaHarvest = 1; // The digging effect oreAndStone.EffectActions = new int[] { 11 }; oreAndStone.EffectSounds = new int[] { 0x125, 0x126 }; oreAndStone.EffectCounts = new int[] { 1 }; oreAndStone.EffectDelay = TimeSpan.FromSeconds(1.6); oreAndStone.EffectSoundDelay = TimeSpan.FromSeconds(0.9); oreAndStone.NoResourcesMessage = 503040; // There is no metal here to mine. oreAndStone.DoubleHarvestMessage = 503042; // Someone has gotten to the metal before you. oreAndStone.TimedOutOfRangeMessage = 503041; // You have moved too far away to continue mining. oreAndStone.OutOfRangeMessage = 500446; // That is too far away. oreAndStone.FailMessage = 503043; // You loosen some rocks but fail to find any useable ore. oreAndStone.PackFullMessage = 1010481; // Your backpack is full, so the ore you mined is lost. oreAndStone.ToolBrokeMessage = 1044038; // You have worn out your tool! oreAndStone.PlaceAtFeetIfFull = true; res = new HarvestResource[] { new HarvestResource(00.0, 00.0, 100.0, 1007072, typeof(IronOre)), }; veins = new HarvestVein[] { new HarvestVein(100.0, 0.0, res[0], null), // Iron }; oreAndStone.Resources = res; oreAndStone.Veins = veins; Definitions.Add(oreAndStone); #endregion #region Mining for sand /*HarvestDefinition sand = m_Sand = new HarvestDefinition(); * * // Resource banks are every 8x8 tiles * sand.BankWidth = 8; * sand.BankHeight = 8; * * // Every bank holds from 6 to 12 sand * sand.MinTotal = 6; * sand.MaxTotal = 12; * * // A resource bank will respawn its content every 10 to 20 minutes * sand.MinRespawn = TimeSpan.FromMinutes( 10.0 ); * sand.MaxRespawn = TimeSpan.FromMinutes( 20.0 ); * * // Skill checking is done on the Mining skill * sand.Skill = SkillName.Mining; * * // Set the list of harvestable tiles * sand.Tiles = m_SandTiles; * * // Players must be within 2 tiles to harvest * sand.MaxRange = 2; * * // One sand per harvest action * sand.ConsumedPerHarvest = 1; * sand.ConsumedPerFeluccaHarvest = 1; * * // The digging effect * sand.EffectActions = new int[]{ 11 }; * sand.EffectSounds = new int[]{ 0x125, 0x126 }; * sand.EffectCounts = new int[]{ 6 }; * sand.EffectDelay = TimeSpan.FromSeconds( 1.6 ); * sand.EffectSoundDelay = TimeSpan.FromSeconds( 0.9 ); * * sand.NoResourcesMessage = 1044629; // There is no sand here to mine. * sand.DoubleHarvestMessage = 1044629; // There is no sand here to mine. * sand.TimedOutOfRangeMessage = 503041; // You have moved too far away to continue mining. * sand.OutOfRangeMessage = 500446; // That is too far away. * sand.FailMessage = 1044630; // You dig for a while but fail to find any of sufficient quality for glassblowing. * sand.PackFullMessage = 1044632; // Your backpack can't hold the sand, and it is lost! * sand.ToolBrokeMessage = 1044038; // You have worn out your tool! * * res = new HarvestResource[] * { * new HarvestResource( 100.0, 70.0, 400.0, 1044631, typeof( Sand ) ) * }; * * veins = new HarvestVein[] * { * new HarvestVein( 100.0, 0.0, res[0], null ) * }; * * sand.Resources = res; * sand.Veins = veins; * * Definitions.Add( sand );*/ #endregion }
public PhysX(TargetInfo Target) { Type = ModuleType.External; // Determine which kind of libraries to link against PhysXLibraryMode LibraryMode = GetPhysXLibraryMode(Target.Configuration); // Quick Mac hack if (Target.Platform == UnrealTargetPlatform.Mac && (LibraryMode == PhysXLibraryMode.Checked || LibraryMode == PhysXLibraryMode.Shipping)) { LibraryMode = PhysXLibraryMode.Profile; } string LibrarySuffix = GetPhysXLibrarySuffix(LibraryMode); Definitions.Add("WITH_PHYSX=1"); if (UEBuildConfiguration.bCompileAPEX == false) { // Since APEX is dependent on PhysX, if APEX is not being include, set the flag properly. // This will properly cover the case where PhysX is compiled but APEX is not. Definitions.Add("WITH_APEX=0"); } if (UEBuildConfiguration.bCompilePhysXVehicle == false) { // Since PhysX Vehicle is dependent on PhysX, if Vehicle is not being include, set the flag properly. // This will properly cover the case where PhysX is compiled but Vehicle is not. Definitions.Add("WITH_VEHICLE=0"); } if (LibraryMode == PhysXLibraryMode.Shipping) { Definitions.Add("WITH_PHYSX_RELEASE=1"); } else { Definitions.Add("WITH_PHYSX_RELEASE=0"); } if (LibraryMode == PhysXLibraryMode.Checked) { Definitions.Add("WITH_PHYSX_CHECKED=1"); } else { Definitions.Add("WITH_PHYSX_CHECKED=0"); } string PhysXVersion = "PhysX-3.3"; string PhysXDir = UEBuildConfiguration.UEThirdPartySourceDirectory + "PhysX/" + PhysXVersion + "/"; string PhysXLibDir = PhysXDir + "lib/"; PublicSystemIncludePaths.AddRange( new string[] { PhysXDir + "include", PhysXDir + "include/foundation", PhysXDir + "include/cooking", PhysXDir + "include/common", PhysXDir + "include/extensions", PhysXDir + "include/geometry", PhysXDir + "include/vehicle" } ); // Libraries and DLLs for windows platform if (Target.Platform == UnrealTargetPlatform.Win64) { PublicSystemIncludePaths.Add(PhysXDir + "include/foundation/windows"); PhysXLibDir += "Win64/VS" + WindowsPlatform.GetVisualStudioCompilerVersionName(); PublicLibraryPaths.Add(PhysXLibDir); string[] StaticLibrariesX64 = new string[] { "PhysX3{0}_x64.lib", "PhysX3Extensions{0}.lib", "PhysX3Cooking{0}_x64.lib", "PhysX3Common{0}_x64.lib", "PhysX3Vehicle{0}.lib", "PxTask{0}.lib", "PhysXVisualDebuggerSDK{0}.lib", "PhysXProfileSDK{0}.lib" }; string[] DelayLoadDLLsX64 = new string[] { "PhysX3{0}_x64.dll", "PhysX3Cooking{0}_x64.dll", "PhysX3Common{0}_x64.dll" }; string[] RuntimeDependenciesX64 = new string[] { "PhysX3{0}_x64.dll", "PhysX3Common{0}_x64.dll", "PhysX3Cooking{0}_x64.dll", }; foreach (string Lib in StaticLibrariesX64) { PublicAdditionalLibraries.Add(String.Format(Lib, LibrarySuffix)); } foreach (string DLL in DelayLoadDLLsX64) { PublicDelayLoadDLLs.Add(String.Format(DLL, LibrarySuffix)); } PublicDelayLoadDLLs.Add("nvToolsExt64_1.dll"); string PhysXBinariesDir = String.Format("$(EngineDir)/Binaries/ThirdParty/PhysX/{0}/Win64/VS{1}/", PhysXVersion, WindowsPlatform.GetVisualStudioCompilerVersionName()); foreach (string DLL in RuntimeDependenciesX64) { string FileName = PhysXBinariesDir + String.Format(DLL, LibrarySuffix); RuntimeDependencies.Add(FileName, StagedFileType.NonUFS); RuntimeDependencies.Add(Path.ChangeExtension(FileName, ".pdb"), StagedFileType.DebugNonUFS); } RuntimeDependencies.Add(PhysXBinariesDir + "nvToolsExt64_1.dll", StagedFileType.NonUFS); } else if (Target.Platform == UnrealTargetPlatform.Win32 || (Target.Platform == UnrealTargetPlatform.HTML5 && Target.Architecture == "-win32")) { PublicIncludePaths.Add(PhysXDir + "include/foundation/windows"); PhysXLibDir += "Win32/VS" + WindowsPlatform.GetVisualStudioCompilerVersionName(); PublicLibraryPaths.Add(PhysXLibDir); string[] StaticLibrariesX86 = new string[] { "PhysX3{0}_x86.lib", "PhysX3Extensions{0}.lib", "PhysX3Cooking{0}_x86.lib", "PhysX3Common{0}_x86.lib", "PhysX3Vehicle{0}.lib", "PxTask{0}.lib", "PhysXVisualDebuggerSDK{0}.lib", "PhysXProfileSDK{0}.lib" }; string[] DelayLoadDLLsX86 = new string[] { "PhysX3{0}_x86.dll", "PhysX3Cooking{0}_x86.dll", "PhysX3Common{0}_x86.dll" }; string[] RuntimeDependenciesX86 = new string[] { "PhysX3{0}_x86.dll", "PhysX3Common{0}_x86.dll", "PhysX3Cooking{0}_x86.dll", }; foreach (string Lib in StaticLibrariesX86) { PublicAdditionalLibraries.Add(String.Format(Lib, LibrarySuffix)); } foreach (string DLL in DelayLoadDLLsX86) { PublicDelayLoadDLLs.Add(String.Format(DLL, LibrarySuffix)); } PublicDelayLoadDLLs.Add("nvToolsExt32_1.dll"); string PhysXBinariesDir = String.Format("$(EngineDir)/Binaries/ThirdParty/PhysX/{0}/Win32/VS{1}/", PhysXVersion, WindowsPlatform.GetVisualStudioCompilerVersionName()); foreach (string DLL in RuntimeDependenciesX86) { string FileName = PhysXBinariesDir + String.Format(DLL, LibrarySuffix); RuntimeDependencies.Add(FileName, StagedFileType.NonUFS); RuntimeDependencies.Add(Path.ChangeExtension(FileName, ".pdb"), StagedFileType.DebugNonUFS); } RuntimeDependencies.Add(PhysXBinariesDir + "nvToolsExt32_1.dll", StagedFileType.NonUFS); } else if (Target.Platform == UnrealTargetPlatform.Mac) { PublicSystemIncludePaths.Add(PhysXDir + "include/foundation/unix"); PhysXLibDir += "/osx64"; PublicLibraryPaths.Add(PhysXLibDir); string[] StaticLibrariesMac = new string[] { PhysXLibDir + "/libLowLevel{0}.a", PhysXLibDir + "/libLowLevelCloth{0}.a", PhysXLibDir + "/libPhysX3{0}.a", PhysXLibDir + "/libPhysX3Extensions{0}.a", PhysXLibDir + "/libPhysX3Cooking{0}.a", PhysXLibDir + "/libPhysX3Common{0}.a", PhysXLibDir + "/libPhysX3Vehicle{0}.a", PhysXLibDir + "/libPxTask{0}.a", PhysXLibDir + "/libPhysXVisualDebuggerSDK{0}.a", PhysXLibDir + "/libPhysXProfileSDK{0}.a", PhysXLibDir + "/libPvdRuntime{0}.a", PhysXLibDir + "/libSceneQuery{0}.a", PhysXLibDir + "/libSimulationController{0}.a" }; foreach (string Lib in StaticLibrariesMac) { PublicAdditionalLibraries.Add(String.Format(Lib, LibrarySuffix)); } } else if (Target.Platform == UnrealTargetPlatform.Android) { PublicSystemIncludePaths.Add(PhysXDir + "include/foundation/unix"); PublicLibraryPaths.Add(PhysXLibDir + "Android/ARMv7"); PublicLibraryPaths.Add(PhysXLibDir + "Android/x86"); PublicLibraryPaths.Add(PhysXLibDir + "Android/arm64"); PublicLibraryPaths.Add(PhysXLibDir + "Android/x64"); string[] StaticLibrariesAndroid = new string[] { "LowLevel{0}", "LowLevelCloth{0}", "PhysX3{0}", "PhysX3Extensions{0}", // "PhysX3Cooking{0}", // not needed until Apex "PhysX3Common{0}", "PhysX3Vehicle{0}", "PxTask{0}", "PhysXVisualDebuggerSDK{0}", "PhysXProfileSDK{0}", "PvdRuntime{0}", "SceneQuery{0}", "SimulationController{0}", }; // shipping libs do not need this if (LibraryMode != PhysXLibraryMode.Shipping) { // use for profiling, but crash handler won't work // PublicAdditionalLibraries.Add("nvToolsExt"); // disables profiling, crash handler will work PublicAdditionalLibraries.Add("nvToolsExtStub"); } foreach (string Lib in StaticLibrariesAndroid) { PublicAdditionalLibraries.Add(String.Format(Lib, LibrarySuffix)); } } else if (Target.Platform == UnrealTargetPlatform.Linux) { PhysXLibDir += "/Linux/" + Target.Architecture; PublicSystemIncludePaths.Add(PhysXDir + "include/foundation/unix"); PublicLibraryPaths.Add(PhysXLibDir); string[] StaticLibrariesLinux = new string[] { "rt", "LowLevel{0}", "LowLevelCloth{0}", "PhysX3{0}", "PhysX3Extensions{0}", "PhysX3Cooking{0}", "PhysX3Common{0}", "PhysX3Vehicle{0}", "PxTask{0}", "PhysXVisualDebuggerSDK{0}", "PhysXProfileSDK{0}", "PvdRuntime{0}", "SceneQuery{0}", "SimulationController{0}", }; if (LibraryMode == PhysXLibraryMode.Debug && BuildConfiguration.bDebugBuildsActuallyUseDebugCRT) { //@TODO: Needed? PublicAdditionalLibraries.Add("m"); } foreach (string Lib in StaticLibrariesLinux) { PublicAdditionalLibraries.Add(String.Format(Lib, LibrarySuffix)); } } else if (Target.Platform == UnrealTargetPlatform.IOS || Target.Platform == UnrealTargetPlatform.TVOS) { PublicSystemIncludePaths.Add(PhysXDir + "include/foundation/unix"); PhysXLibDir = Path.Combine(PhysXLibDir, Target.Platform.ToString()); PublicLibraryPaths.Add(PhysXLibDir); string[] PhysXLibs = new string[] { "LowLevel", "LowLevelCloth", "PhysX3", "PhysX3Common", // "PhysX3Cooking", // not needed until Apex "PhysX3Extensions", "PhysX3Vehicle", "PxTask", "PhysXVisualDebuggerSDK", "PhysXProfileSDK", "PvdRuntime", "SceneQuery", "SimulationController", }; foreach (string PhysXLib in PhysXLibs) { PublicAdditionalLibraries.Add(PhysXLib + LibrarySuffix); PublicAdditionalShadowFiles.Add(Path.Combine(PhysXLibDir, "lib" + PhysXLib + LibrarySuffix + ".a")); } } else if (Target.Platform == UnrealTargetPlatform.HTML5) { PublicSystemIncludePaths.Add(PhysXDir + "include/foundation/unix"); PhysXLibDir = Path.Combine(PhysXLibDir, "HTML5/"); string[] PhysXLibs = new string[] { "LowLevel", "LowLevelCloth", "PhysX3", "PhysX3Common", "PhysX3Cooking", "PhysX3Extensions", "PxTask", "PhysXVisualDebuggerSDK", "PhysXProfileSDK", "PvdRuntime", "SceneQuery", "SimulationController", }; foreach (var lib in PhysXLibs) { if (!lib.Contains("Cooking") || Target.IsCooked == false) { PublicAdditionalLibraries.Add(PhysXLibDir + lib + (UEBuildConfiguration.bCompileForSize ? "_Oz" : "") + ".bc"); } } if (UEBuildConfiguration.bCompilePhysXVehicle) { string[] PhysXVehicleLibs = new string[] { "PhysX3Vehicle", }; foreach (var lib in PhysXVehicleLibs) { if (!lib.Contains("Cooking") || Target.IsCooked == false) { PublicAdditionalLibraries.Add(PhysXLibDir + lib + (UEBuildConfiguration.bCompileForSize ? "_Oz" : "") + ".bc"); } } } } else if (Target.Platform == UnrealTargetPlatform.PS4) { PublicSystemIncludePaths.Add(PhysXDir + "include/foundation/PS4"); PublicLibraryPaths.Add(PhysXDir + "lib/PS4"); string[] StaticLibrariesPS4 = new string[] { "PhysX3{0}", "PhysX3Extensions{0}", "PhysX3Cooking{0}", "PhysX3Common{0}", "PhysX3Vehicle{0}", "PxTask{0}", "PhysXVisualDebuggerSDK{0}", "PhysXProfileSDK{0}" }; foreach (string Lib in StaticLibrariesPS4) { PublicAdditionalLibraries.Add(String.Format(Lib, LibrarySuffix)); } } else if (Target.Platform == UnrealTargetPlatform.XboxOne) { // Use reflection to allow type not to exist if console code is not present System.Type XboxOnePlatformType = System.Type.GetType("UnrealBuildTool.XboxOnePlatform,UnrealBuildTool"); if (XboxOnePlatformType != null) { System.Object VersionName = XboxOnePlatformType.GetMethod("GetVisualStudioCompilerVersionName").Invoke(null, null); PublicSystemIncludePaths.Add("include/foundation/xboxone"); PublicLibraryPaths.Add(PhysXDir + "Lib/XboxOne/VS" + VersionName.ToString()); string[] StaticLibrariesXB1 = new string[] { "PhysX3{0}.lib", "PhysX3Extensions{0}.lib", "PhysX3Cooking{0}.lib", "PhysX3Common{0}.lib", "PhysX3Vehicle{0}.lib", "PxTask{0}.lib", "PhysXVisualDebuggerSDK{0}.lib", "PhysXProfileSDK{0}.lib" }; foreach (string Lib in StaticLibrariesXB1) { PublicAdditionalLibraries.Add(String.Format(Lib, LibrarySuffix)); } } } }
public HoudiniEngineRuntime(TargetInfo Target) { string HFSPath = ""; string HoudiniVersion = "14.0.374"; // Check if we are compiling on unsupported platforms. if (Target.Platform != UnrealTargetPlatform.Win64 && Target.Platform != UnrealTargetPlatform.Mac) { string Err = string.Format("Houdini Engine : Compiling on unsupported platform."); System.Console.WriteLine(Err); throw new BuildException(Err); } if (HFSPath == "") { if (Target.Platform == UnrealTargetPlatform.Win64) { // We first check if Houdini Engine is installed. HFSPath = "C:/Program Files/Side Effects Software/Houdini Engine " + HoudiniVersion; if (!Directory.Exists(HFSPath)) { // If Houdini Engine is not installed, we check for Houdini installation. HFSPath = "C:/Program Files/Side Effects Software/Houdini " + HoudiniVersion; if (!Directory.Exists(HFSPath)) { string Err = string.Format("Houdini Engine : Please install Houdini or Houdini Engine {0}", HoudiniVersion); System.Console.WriteLine(Err); throw new BuildException(Err); } } } else if (Target.Platform == UnrealTargetPlatform.Mac) { HFSPath = "/Library/Frameworks/Houdini.framework/Versions/" + HoudiniVersion + "/Resources"; if (!Directory.Exists(HFSPath)) { string Err = string.Format("Houdini Engine : Please install Houdini {0}", HoudiniVersion); System.Console.WriteLine(Err); throw new BuildException(Err); } } } string HAPIIncludePath = HFSPath + "/toolkit/include/HAPI"; if (HFSPath != "") { if (Target.Platform == UnrealTargetPlatform.Win64) { Definitions.Add("HOUDINI_ENGINE_HFS_PATH_DEFINE=" + HFSPath); } } PublicIncludePaths.AddRange( new string[] { // ... add public include paths required here ... HAPIIncludePath, "HoudiniEngineRuntime/Public" } ); PrivateIncludePaths.AddRange( new string[] { "HoudiniEngineRuntime/Private" // ... add other private include paths required here ... } ); // Add common dependencies. PublicDependencyModuleNames.AddRange( new string[] { "Core", "CoreUObject", "Engine", "RenderCore", "ShaderCore", "InputCore", "RHI", "TargetPlatform", "Settings", "Foliage" } ); if (UEBuildConfiguration.bBuildEditor == true) { PublicDependencyModuleNames.AddRange( new string[] { "AssetTools", "UnrealEd", "Slate", "SlateCore", "Projects", "PropertyEditor", "ContentBrowser", "LevelEditor", "MainFrame", "EditorStyle", "EditorWidgets", "AppFramework", "RawMesh" } ); } 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 GameLiftServerSDK(ReadOnlyTargetRules Target) : base(Target) { PublicIncludePaths.AddRange( new string[] { "GameLiftServerSDK/Public" } ); PrivateIncludePaths.AddRange( new string[] { "GameLiftServerSDK/Private", } ); PublicDependencyModuleNames.AddRange( new string[] { "Core", "Projects" } ); PrivateDependencyModuleNames.AddRange( new string[] { } ); DynamicallyLoadedModuleNames.AddRange( new string[] { } ); string BaseDirectory = System.IO.Path.GetFullPath(System.IO.Path.Combine(ModuleDirectory, "..", "..")); string SDKDirectory = System.IO.Path.Combine(BaseDirectory, "ThirdParty", "GameLiftServerSDK", Target.Platform.ToString()); bool bHasGameLiftSDK = System.IO.Directory.Exists(SDKDirectory); if (bHasGameLiftSDK) { if (Target.Type == TargetRules.TargetType.Server) { Definitions.Add("WITH_GAMELIFT=1"); if (Target.Platform == UnrealTargetPlatform.Linux) { SDKDirectory = System.IO.Path.Combine(SDKDirectory, "x86_64-unknown-linux-gnu"); string SDKLib = System.IO.Path.Combine(SDKDirectory, "libaws-cpp-sdk-gamelift-server.so"); PublicLibraryPaths.Add(SDKDirectory); PublicAdditionalLibraries.Add(SDKLib); RuntimeDependencies.Add(new RuntimeDependency(SDKLib)); } else if (Target.Platform == UnrealTargetPlatform.Win64) { PublicLibraryPaths.Add(SDKDirectory); PublicAdditionalLibraries.Add(System.IO.Path.Combine(SDKDirectory, "aws-cpp-sdk-gamelift-server.lib")); PublicDelayLoadDLLs.Add("aws-cpp-sdk-gamelift-server.dll"); string SDKLibWindows = System.IO.Path.Combine(SDKDirectory, "aws-cpp-sdk-gamelift-server.dll"); RuntimeDependencies.Add(new RuntimeDependency(SDKLibWindows)); } } else { Definitions.Add("WITH_GAMELIFT=0"); } } else { Definitions.Add("WITH_GAMELIFT=0"); } }
public ICU(TargetInfo Target) { Type = ModuleType.External; string ICUVersion = "icu4c-53_1"; string ICURootPath = UEBuildConfiguration.UEThirdPartySourceDirectory + "ICU/" + ICUVersion + "/"; // Includes PublicSystemIncludePaths.Add(ICURootPath + "include" + "/"); string PlatformFolderName = Target.Platform.ToString(); string TargetSpecificPath = ICURootPath + PlatformFolderName + "/"; if (Target.Platform == UnrealTargetPlatform.HTML5 && Target.Architecture == "-win32") { TargetSpecificPath = ICURootPath + "Win32/"; } if ((Target.Platform == UnrealTargetPlatform.Win64) || (Target.Platform == UnrealTargetPlatform.Win32) || (Target.Platform == UnrealTargetPlatform.HTML5 && Target.Architecture == "-win32")) { string VSVersionFolderName = "VS" + WindowsPlatform.GetVisualStudioCompilerVersionName(); TargetSpecificPath += VSVersionFolderName + "/"; string[] LibraryNameStems = { "dt", // Data "uc", // Unicode Common "in", // Internationalization "le", // Layout Engine "lx", // Layout Extensions "io" // Input/Output }; string LibraryNamePostfix = (Target.Configuration == UnrealTargetConfiguration.Debug && BuildConfiguration.bDebugBuildsActuallyUseDebugCRT) ? "d" : string.Empty; // Library Paths PublicLibraryPaths.Add(TargetSpecificPath + "lib" + "/"); EICULinkType ICULinkType = Target.IsMonolithic ? EICULinkType.Static : EICULinkType.Dynamic; switch (ICULinkType) { case EICULinkType.Static: foreach (string Stem in LibraryNameStems) { string LibraryName = "sicu" + Stem + LibraryNamePostfix + "." + "lib"; PublicAdditionalLibraries.Add(LibraryName); } break; case EICULinkType.Dynamic: foreach (string Stem in LibraryNameStems) { string LibraryName = "icu" + Stem + LibraryNamePostfix + "." + "lib"; PublicAdditionalLibraries.Add(LibraryName); } foreach (string Stem in LibraryNameStems) { string LibraryName = "icu" + Stem + LibraryNamePostfix + "53" + "." + "dll"; PublicDelayLoadDLLs.Add(LibraryName); } if (Target.Platform == UnrealTargetPlatform.Win64 || Target.Platform == UnrealTargetPlatform.Win32) { string BinariesDir = String.Format("$(EngineDir)/Binaries/ThirdParty/ICU/{0}/{1}/VS{2}/", ICUVersion, Target.Platform.ToString(), WindowsPlatform.GetVisualStudioCompilerVersionName()); foreach (string Stem in LibraryNameStems) { string LibraryName = BinariesDir + String.Format("icu{0}{1}53.dll", Stem, LibraryNamePostfix); RuntimeDependencies.Add(new RuntimeDependency(LibraryName)); } } break; } } else if (Target.Platform == UnrealTargetPlatform.Linux || Target.Platform == UnrealTargetPlatform.Android) { string StaticLibraryExtension = "a"; switch (Target.Platform) { case UnrealTargetPlatform.Linux: TargetSpecificPath += Target.Architecture + "/"; break; case UnrealTargetPlatform.Android: PublicLibraryPaths.Add(TargetSpecificPath + "ARMv7/lib"); PublicLibraryPaths.Add(TargetSpecificPath + "ARM64/lib"); PublicLibraryPaths.Add(TargetSpecificPath + "x86/lib"); PublicLibraryPaths.Add(TargetSpecificPath + "x64/lib"); break; } string[] LibraryNameStems = { "data", // Data "uc", // Unicode Common "i18n", // Internationalization "le", // Layout Engine "lx", // Layout Extensions "io" // Input/Output }; string LibraryNamePostfix = (Target.Configuration == UnrealTargetConfiguration.Debug && BuildConfiguration.bDebugBuildsActuallyUseDebugCRT) ? "d" : string.Empty; // Library Paths EICULinkType ICULinkType = (Target.Platform == UnrealTargetPlatform.Android || Target.IsMonolithic) ? EICULinkType.Static : EICULinkType.Dynamic; switch (ICULinkType) { case EICULinkType.Static: foreach (string Stem in LibraryNameStems) { string LibraryName = "icu" + Stem + LibraryNamePostfix; if (Target.Platform == UnrealTargetPlatform.Android) { // we will filter out in the toolchain PublicAdditionalLibraries.Add(LibraryName); // Android requires only the filename. } else { PublicAdditionalLibraries.Add(TargetSpecificPath + "lib/" + "lib" + LibraryName + "." + StaticLibraryExtension); // Linux seems to need the path, not just the filename. } } break; case EICULinkType.Dynamic: if (Target.Platform == UnrealTargetPlatform.Linux) { string PathToBinary = String.Format("$(EngineDir)/Binaries/ThirdParty/ICU/{0}/{1}/{2}/", ICUVersion, Target.Platform.ToString(), Target.Architecture); foreach (string Stem in LibraryNameStems) { string LibraryName = "icu" + Stem + LibraryNamePostfix; string LibraryPath = UEBuildConfiguration.UEThirdPartyBinariesDirectory + "ICU/icu4c-53_1/Linux/" + Target.Architecture + "/"; PublicLibraryPaths.Add(LibraryPath); PublicAdditionalLibraries.Add(LibraryName); // add runtime dependencies (for staging) RuntimeDependencies.Add(new RuntimeDependency(PathToBinary + "lib" + LibraryName + ".so")); RuntimeDependencies.Add(new RuntimeDependency(PathToBinary + "lib" + LibraryName + ".so.53")); // version-dependent } } break; } } else if (Target.Platform == UnrealTargetPlatform.Mac || Target.Platform == UnrealTargetPlatform.IOS) { string StaticLibraryExtension = "a"; string DynamicLibraryExtension = "dylib"; string[] LibraryNameStems = { "data", // Data "uc", // Unicode Common "i18n", // Internationalization "le", // Layout Engine "lx", // Layout Extensions "io" // Input/Output }; string LibraryNamePostfix = (Target.Configuration == UnrealTargetConfiguration.Debug && BuildConfiguration.bDebugBuildsActuallyUseDebugCRT) ? "d" : string.Empty; EICULinkType ICULinkType = (Target.Platform == UnrealTargetPlatform.IOS || Target.IsMonolithic) ? EICULinkType.Static : EICULinkType.Dynamic; // Library Paths switch (ICULinkType) { case EICULinkType.Static: foreach (string Stem in LibraryNameStems) { string LibraryName = "libicu" + Stem + LibraryNamePostfix + "." + StaticLibraryExtension; PublicAdditionalLibraries.Add(TargetSpecificPath + "lib/" + LibraryName); if (Target.Platform == UnrealTargetPlatform.IOS) { PublicAdditionalShadowFiles.Add(TargetSpecificPath + "lib/" + LibraryName); } } break; case EICULinkType.Dynamic: foreach (string Stem in LibraryNameStems) { if (Target.Platform == UnrealTargetPlatform.Mac) { string LibraryName = "libicu" + Stem + ".53.1" + LibraryNamePostfix + "." + DynamicLibraryExtension; string LibraryPath = UEBuildConfiguration.UEThirdPartyBinariesDirectory + "ICU/icu4c-53_1/Mac/" + LibraryName; PublicDelayLoadDLLs.Add(LibraryPath); PublicAdditionalShadowFiles.Add(LibraryPath); } else if (Target.Platform == UnrealTargetPlatform.Linux) { string LibraryName = "icu" + Stem + LibraryNamePostfix; string LibraryPath = UEBuildConfiguration.UEThirdPartyBinariesDirectory + "ICU/icu4c-53_1/Linux/" + Target.Architecture + "/"; PublicLibraryPaths.Add(LibraryPath); PublicAdditionalLibraries.Add(LibraryName); } } break; } } else if (Target.Platform == UnrealTargetPlatform.HTML5) { // we don't bother with debug libraries on HTML5. Mainly because debugging isn't viable on html5 currently string StaticLibraryExtension = "bc"; string[] LibraryNameStems = { "data", // Data "uc", // Unicode Common "i18n", // Internationalization "le", // Layout Engine "lx", // Layout Extensions "io" // Input/Output }; foreach (string Stem in LibraryNameStems) { string LibraryName = "libicu" + Stem + "." + StaticLibraryExtension; PublicAdditionalLibraries.Add(TargetSpecificPath + LibraryName); } } else if (Target.Platform == UnrealTargetPlatform.PS4) { string LibraryNamePrefix = "sicu"; string[] LibraryNameStems = { "dt", // Data "uc", // Unicode Common "in", // Internationalization "le", // Layout Engine "lx", // Layout Extensions "io" // Input/Output }; string LibraryNamePostfix = (Target.Configuration == UnrealTargetConfiguration.Debug) ? "d" : string.Empty; string LibraryExtension = "lib"; foreach (string Stem in LibraryNameStems) { string LibraryName = ICURootPath + "PS4/lib/" + LibraryNamePrefix + Stem + LibraryNamePostfix + "." + LibraryExtension; PublicAdditionalLibraries.Add(LibraryName); } } else if (Target.Platform == UnrealTargetPlatform.XboxOne) { // Use reflection to allow type not to exist if console code is not present System.Type XboxOnePlatformType = System.Type.GetType("UnrealBuildTool.XboxOnePlatform,UnrealBuildTool"); if (XboxOnePlatformType != null) { string LibraryNamePrefix = "sicu"; string[] LibraryNameStems = { "dt", // Data "uc", // Unicode Common "in", // Internationalization "le", // Layout Engine "lx", // Layout Extensions "io" // Input/Output }; string LibraryNamePostfix = (Target.Configuration == UnrealTargetConfiguration.Debug && BuildConfiguration.bDebugBuildsActuallyUseDebugCRT) ? "d" : string.Empty; string LibraryExtension = "lib"; foreach (string Stem in LibraryNameStems) { System.Object VersionName = XboxOnePlatformType.GetMethod("GetVisualStudioCompilerVersionName").Invoke(null, null); string LibraryName = ICURootPath + "XboxOne/VS" + VersionName.ToString() + "/lib/" + LibraryNamePrefix + Stem + LibraryNamePostfix + "." + LibraryExtension; PublicAdditionalLibraries.Add(LibraryName); } } } // common defines if ((Target.Platform == UnrealTargetPlatform.Win64) || (Target.Platform == UnrealTargetPlatform.Win32) || (Target.Platform == UnrealTargetPlatform.Linux) || (Target.Platform == UnrealTargetPlatform.Android) || (Target.Platform == UnrealTargetPlatform.Mac) || (Target.Platform == UnrealTargetPlatform.IOS) || (Target.Platform == UnrealTargetPlatform.PS4) || (Target.Platform == UnrealTargetPlatform.XboxOne) || (Target.Platform == UnrealTargetPlatform.HTML5)) { // Definitions Definitions.Add("U_USING_ICU_NAMESPACE=0"); // Disables a using declaration for namespace "icu". Definitions.Add("U_STATIC_IMPLEMENTATION"); // Necessary for linking to ICU statically. Definitions.Add("U_NO_DEFAULT_INCLUDE_UTF_HEADERS=1"); // Disables unnecessary inclusion of headers - inclusions are for ease of use. Definitions.Add("UNISTR_FROM_CHAR_EXPLICIT=explicit"); // Makes UnicodeString constructors for ICU character types explicit. Definitions.Add("UNISTR_FROM_STRING_EXPLICIT=explicit"); // Makes UnicodeString constructors for "char"/ICU string types explicit. Definitions.Add("UCONFIG_NO_TRANSLITERATION=1"); // Disables declarations and compilation of unused ICU transliteration functionality. } if (Target.Platform == UnrealTargetPlatform.PS4) { // Definitions Definitions.Add("ICU_NO_USER_DATA_OVERRIDE=1"); Definitions.Add("U_PLATFORM=U_PF_ORBIS"); } if (Target.Platform == UnrealTargetPlatform.XboxOne) { // Definitions Definitions.Add("ICU_NO_USER_DATA_OVERRIDE=1"); Definitions.Add("U_PLATFORM=U_PF_DURANGO"); } }
public Engine(TargetInfo Target) { PrivatePCHHeaderFile = "Private/EnginePrivatePCH.h"; SharedPCHHeaderFile = "Public/EngineSharedPCH.h"; PublicIncludePathModuleNames.AddRange(new string[] { "Renderer", "PacketHandler", "NetworkReplayStreaming" }); PrivateIncludePaths.AddRange( new string[] { "Developer/DerivedDataCache/Public", "Runtime/SynthBenchmark/Public", "Runtime/Engine/Private", } ); PrivateIncludePathModuleNames.AddRange( new string[] { "TargetPlatform", "ImageWrapper", "HeadMountedDisplay", "Advertising", "NetworkReplayStreaming", "MovieSceneCapture", "AutomationWorker", "MovieSceneCapture", "DesktopPlatform", } ); if (Target.Configuration != UnrealTargetConfiguration.Shipping) { PrivateIncludePathModuleNames.AddRange(new string[] { "TaskGraph" }); } if (Target.Configuration != UnrealTargetConfiguration.Shipping) { PrivateIncludePathModuleNames.AddRange( new string[] { "SlateReflector", } ); DynamicallyLoadedModuleNames.AddRange( new string[] { "SlateReflector", } ); } PublicDependencyModuleNames.AddRange( new string[] { "Core", "CoreUObject", "Json", "SlateCore", "Slate", "InputCore", "Messaging", "RenderCore", "RHI", "ShaderCore", "AssetRegistry", // Here until FAssetData is moved to engine "EngineMessages", "EngineSettings", "SynthBenchmark", "GameplayTags", "AIModule", "DatabaseSupport", "PacketHandler", "HardwareSurvey", } ); if (Target.Type == TargetRules.TargetType.Editor) { PrivateIncludePathModuleNames.AddRange(new string[] { "CrashTracker" }); DynamicallyLoadedModuleNames.AddRange(new string[] { "CrashTracker" }); PublicDependencyModuleNames.AddRange( new string[] { } ); } PrivateDependencyModuleNames.AddRange( new string[] { "AppFramework", "Networking", "Sockets", "Landscape", "UMG", "Projects", "Internationalization", "MaterialShaderQualitySettings", "CinematicCamera", "Analytics", "AnalyticsET", } ); // to prevent "causes WARNING: Non-editor build cannot depend on non-redistributable modules." if (Target.Type == TargetRules.TargetType.Editor) { // for now we depend on this PrivateDependencyModuleNames.Add("RawMesh"); } bool bVariadicTemplatesSupported = true; if (Target.Platform == UnrealTargetPlatform.XboxOne) { // Use reflection to allow type not to exist if console code is not present System.Type XboxOnePlatformType = System.Type.GetType("UnrealBuildTool.XboxOnePlatform,UnrealBuildTool"); if (XboxOnePlatformType != null) { System.Object VersionName = XboxOnePlatformType.GetMethod("GetVisualStudioCompilerVersionName").Invoke(null, null); if (VersionName.ToString().Equals("2012")) { bVariadicTemplatesSupported = false; } } } if (bVariadicTemplatesSupported) { PrivateIncludePathModuleNames.AddRange( new string[] { "MessagingRpc", "PortalRpc", "PortalServices", } ); if (Target.Type == TargetRules.TargetType.Editor) { // these modules require variadic templates PrivateDependencyModuleNames.AddRange( new string[] { "MessagingRpc", "PortalRpc", "PortalServices", } ); } } CircularlyReferencedDependentModules.Add("GameplayTags"); CircularlyReferencedDependentModules.Add("AIModule"); CircularlyReferencedDependentModules.Add("Landscape"); CircularlyReferencedDependentModules.Add("UMG"); CircularlyReferencedDependentModules.Add("MaterialShaderQualitySettings"); CircularlyReferencedDependentModules.Add("CinematicCamera"); // The AnimGraphRuntime module is not needed by Engine proper, but it is loaded in LaunchEngineLoop.cpp, // and needs to be listed in an always-included module in order to be compiled into standalone games DynamicallyLoadedModuleNames.Add("AnimGraphRuntime"); // So does Geometry Cache DynamicallyLoadedModuleNames.Add("GeometryCache"); DynamicallyLoadedModuleNames.AddRange( new string[] { "MovieScene", "MovieSceneCapture", "MovieSceneTracks", "HeadMountedDisplay", "StreamingPauseRendering", } ); PrivateIncludePathModuleNames.Add("LightPropagationVolumeRuntime"); if (Target.Type != TargetRules.TargetType.Server) { PrivateIncludePathModuleNames.AddRange( new string[] { "SlateNullRenderer", "SlateRHIRenderer" } ); DynamicallyLoadedModuleNames.AddRange( new string[] { "SlateNullRenderer", "SlateRHIRenderer" } ); } if (Target.Type == TargetRules.TargetType.Server || Target.Type == TargetRules.TargetType.Editor) { PrivateDependencyModuleNames.Add("PerfCounters"); } if (UEBuildConfiguration.bBuildDeveloperTools) { // Add "BlankModule" so that it gets compiled as an example and will be maintained and tested. This can be removed // at any time if needed. The module isn't actually loaded by the engine so there is no runtime cost. DynamicallyLoadedModuleNames.Add("BlankModule"); if (Target.Type != TargetRules.TargetType.Server) { PrivateIncludePathModuleNames.Add("MeshUtilities"); DynamicallyLoadedModuleNames.Add("MeshUtilities"); PrivateDependencyModuleNames.AddRange( new string[] { "ImageCore", "RawMesh" }); } if (Target.Configuration != UnrealTargetConfiguration.Shipping && Target.Configuration != UnrealTargetConfiguration.Test && Target.Type != TargetRules.TargetType.Server) { PrivateDependencyModuleNames.Add("CollisionAnalyzer"); CircularlyReferencedDependentModules.Add("CollisionAnalyzer"); PrivateDependencyModuleNames.Add("LogVisualizer"); CircularlyReferencedDependentModules.Add("LogVisualizer"); } if (Target.Platform == UnrealTargetPlatform.Win64) { DynamicallyLoadedModuleNames.AddRange( new string[] { "WindowsTargetPlatform", "WindowsNoEditorTargetPlatform", "WindowsServerTargetPlatform", "WindowsClientTargetPlatform", "AllDesktopTargetPlatform", } ); } else if (Target.Platform == UnrealTargetPlatform.Mac) { DynamicallyLoadedModuleNames.AddRange( new string[] { "MacTargetPlatform", "MacNoEditorTargetPlatform", "MacServerTargetPlatform", "MacClientTargetPlatform", "AllDesktopTargetPlatform", } ); } else if (Target.Platform == UnrealTargetPlatform.Linux) { DynamicallyLoadedModuleNames.AddRange( new string[] { "LinuxTargetPlatform", "LinuxNoEditorTargetPlatform", "LinuxServerTargetPlatform", "LinuxClientTargetPlatform", "AllDesktopTargetPlatform", } ); } } DynamicallyLoadedModuleNames.AddRange( new string[] { "NetworkReplayStreaming", "NullNetworkReplayStreaming", "HttpNetworkReplayStreaming", "Advertising" } ); if (Target.Type.Value != TargetRules.TargetType.Server) { DynamicallyLoadedModuleNames.AddRange( new string[] { "ImageWrapper", "GameLiveStreaming" } ); } if (!UEBuildConfiguration.bBuildRequiresCookedData && UEBuildConfiguration.bCompileAgainstEngine) { DynamicallyLoadedModuleNames.AddRange( new string[] { "DerivedDataCache", "TargetPlatform", "DesktopPlatform" } ); } if (UEBuildConfiguration.bBuildEditor == true) { PublicDependencyModuleNames.AddRange( new string[] { "UnrealEd", "Kismet" } ); // @todo api: Only public because of WITH_EDITOR and UNREALED_API CircularlyReferencedDependentModules.AddRange( new string[] { "UnrealEd", "Kismet" } ); PrivateIncludePathModuleNames.Add("TextureCompressor"); PrivateIncludePaths.Add("Developer/TextureCompressor/Public"); PrivateIncludePathModuleNames.Add("HierarchicalLODUtilities"); DynamicallyLoadedModuleNames.Add("HierarchicalLODUtilities"); } SetupModulePhysXAPEXSupport(Target); if (UEBuildConfiguration.bCompilePhysX && UEBuildConfiguration.bRuntimePhysicsCooking) { DynamicallyLoadedModuleNames.Add("PhysXFormats"); PrivateIncludePathModuleNames.Add("PhysXFormats"); } SetupModuleBox2DSupport(Target); if ((Target.Platform == UnrealTargetPlatform.Win64) || (Target.Platform == UnrealTargetPlatform.Win32)) { AddEngineThirdPartyPrivateStaticDependencies(Target, "UEOgg", "Vorbis", "VorbisFile", "libOpus", "OpenSubdiv" ); if (UEBuildConfiguration.bCompileLeanAndMeanUE == false) { AddEngineThirdPartyPrivateStaticDependencies(Target, "DirectShow"); } // Head Mounted Display support // PrivateIncludePathModuleNames.AddRange(new string[] { "HeadMountedDisplay" }); // DynamicallyLoadedModuleNames.AddRange(new string[] { "HeadMountedDisplay" }); } if (Target.Platform == UnrealTargetPlatform.HTML5 && Target.Architecture == "-win32") { AddEngineThirdPartyPrivateStaticDependencies(Target, "UEOgg", "Vorbis", "VorbisFile" ); } if (Target.Platform == UnrealTargetPlatform.HTML5 && Target.Architecture != "-win32") { PublicDependencyModuleNames.Add("HTML5JS"); } if (Target.Platform == UnrealTargetPlatform.Mac) { AddEngineThirdPartyPrivateStaticDependencies(Target, "UEOgg", "Vorbis", "libOpus" ); PublicFrameworks.AddRange(new string[] { "AVFoundation", "CoreVideo", "CoreMedia" }); } if (Target.Platform == UnrealTargetPlatform.Android) { AddEngineThirdPartyPrivateStaticDependencies(Target, "UEOgg", "Vorbis", "VorbisFile" ); } if (Target.Platform == UnrealTargetPlatform.Linux) { AddEngineThirdPartyPrivateStaticDependencies(Target, "UEOgg", "Vorbis", "VorbisFile", "libOpus" ); } if (UEBuildConfiguration.bCompileRecast) { PrivateDependencyModuleNames.Add("Navmesh"); Definitions.Add("WITH_RECAST=1"); } else { // Because we test WITH_RECAST in public Engine header files, we need to make sure that modules // that import this also have this definition set appropriately. Recast is a private dependency // module, so it's definitions won't propagate to modules that import Engine. Definitions.Add("WITH_RECAST=0"); } // Add a reference to the stats HTML files referenced by UEngine::DumpFPSChartToHTML. Previously staged by CopyBuildToStagingDirectory. if (UEBuildConfiguration.bBuildEditor || Target.Configuration != UnrealTargetConfiguration.Shipping) { RuntimeDependencies.Add("$(EngineDir)/Content/Stats/...", StagedFileType.UFS); } DynamicallyLoadedModuleNames.Add("Niagara"); }
private Mining() { HarvestResource[] res; HarvestVein[] veins; #region Mining for ore and stone HarvestDefinition oreAndStone = new HarvestDefinition(); // Resource banks are every 8x8 tiles oreAndStone.BankWidth = 8; oreAndStone.BankHeight = 8; // Every bank holds from 10 to 34 ore oreAndStone.MinTotal = 10; oreAndStone.MaxTotal = 34; // A resource bank will respawn its content every 10 to 20 minutes oreAndStone.MinRespawn = TimeSpan.FromMinutes(10.0); oreAndStone.MaxRespawn = TimeSpan.FromMinutes(20.0); // Skill checking is done on the Mining skill oreAndStone.Skill = SkillName.Mining; // Set the list of harvestable tiles oreAndStone.Tiles = m_MountainAndCaveTiles; // Players must be within 2 tiles to harvest oreAndStone.MaxRange = 2; // One ore per harvest action oreAndStone.ConsumedPerHarvest = 1; oreAndStone.ConsumedPerFeluccaHarvest = 2; // The digging effect oreAndStone.EffectActions = new[] { 11 }; oreAndStone.EffectSounds = new[] { 0x125, 0x126 }; oreAndStone.EffectCounts = new[] { 1 }; oreAndStone.EffectDelay = TimeSpan.FromSeconds(1.6); oreAndStone.EffectSoundDelay = TimeSpan.FromSeconds(0.9); oreAndStone.NoResourcesMessage = 503040; // There is no metal here to mine. oreAndStone.DoubleHarvestMessage = 503042; // Someone has gotten to the metal before you. oreAndStone.TimedOutOfRangeMessage = 503041; // You have moved too far away to continue mining. oreAndStone.OutOfRangeMessage = 500446; // That is too far away. oreAndStone.FailMessage = 503043; // You loosen some rocks but fail to find any useable ore. oreAndStone.PackFullMessage = 1010481; // Your backpack is full, so the ore you mined is lost. oreAndStone.ToolBrokeMessage = 1044038; // You have worn out your tool! // "You dig some ~ore~ and put in your backpack." res = new[] { new HarvestResource(0.0, 0.0, 0.0, "You dig some Iron ore and put it in your backpack.", typeof(IronOre)), new HarvestResource(1.0, 1.0, 1.0, "You dig some Gold ore and put it in your backpack.", typeof(GoldOre)), new HarvestResource(5.0, 5.0, 5.0, "You dig some Spike ore and put it in your backpack.", typeof(SpikeOre)), new HarvestResource(10.0, 10.0, 10.0, "You dig some Fruity ore and put it in your backpack.", typeof(FruityOre)), new HarvestResource(15.0, 15.0, 15.0, "You dig some Bronze ore and put it in your backpack.", typeof(BronzeOre)), new HarvestResource(20.0, 20.0, 20.0, "You dig some Ice Rock ore and put it in your backpack.", typeof(IceRockOre)), new HarvestResource(25.0, 25.0, 25.0, "You dig some Black Dwarf ore and put it in your backpack.", typeof(BlackDwarfOre)), new HarvestResource(30.0, 30.0, 30.0, "You dig some Dull Copper ore and put it in your backpack.", typeof(DullCopperOre)), new HarvestResource(35.0, 35.0, 35.0, "You dig some Platinum ore and put it in your backpack.", typeof(PlatinumOre)), new HarvestResource(40.0, 40.0, 40.0, "You dig some Silver Rock ore and put it in your backpack.", typeof(SilverRockOre)), new HarvestResource(45.0, 45.0, 45.0, "You dig some Dark Pagan ore and put it in your backpack.", typeof(DarkPaganOre)), new HarvestResource(50.0, 50.0, 50.0, "You dig some Copper ore and put it in your backpack.", typeof(CopperOre)), new HarvestResource(55.0, 55.0, 55.0, "You dig some Mystic ore and put it in your backpack.", typeof(MysticOre)), new HarvestResource(60.0, 60.0, 60.0, "You dig some Spectral ore and put it in your backpack.", typeof(SpectralOre)), new HarvestResource(65.0, 65.0, 65.0, "You dig some Old Britain ore and put it in your backpack.", typeof(OldBritainOre)), new HarvestResource(70.0, 70.0, 70.0, "You dig some Onyx ore and put it in your backpack.", typeof(OnyxOre)), new HarvestResource(75.0, 75.0, 75.0, "You dig some Red Elven ore and put it in your backpack.", typeof(RedElvenOre)), new HarvestResource(80.0, 80.0, 80.0, "You dig some Undead ore and put it in your backpack.", typeof(UndeadOre)), new HarvestResource(85.0, 85.0, 85.0, "You dig some Pyrite ore and put it in your backpack.", typeof(PyriteOre)), new HarvestResource(90.0, 90.0, 90.0, "You dig some Virginity ore and put it in your backpack.", typeof(VirginityOre)), new HarvestResource(95.0, 95.0, 95.0, "You dig some Malachite ore and put it in your backpack.", typeof(MalachiteOre)), new HarvestResource(97.0, 97.0, 97.0, "You dig some Lavarock ore and put it in your backpack.", typeof(LavarockOre)), new HarvestResource(98.0, 98.0, 98.0, "You dig some Azurite ore and put it in your backpack.", typeof(AzuriteOre)), new HarvestResource(100.0, 100.0, 100.0, "You dig some Dripstone ore and put it in your backpack.", typeof(DripstoneOre)), new HarvestResource(104.0, 104.0, 104.0, "You dig some Executor ore and put it in your backpack.", typeof(ExecutorOre)), new HarvestResource(108.0, 108.0, 108.0, "You dig some Peachblue ore and put it in your backpack.", typeof(PeachblueOre)), new HarvestResource(112.0, 112.0, 112.0, "You dig some Destruction ore and put it in your backpack.", typeof(DestructionOre)), new HarvestResource(116.0, 116.0, 116.0, "You dig some Anra ore and put it in your backpack.", typeof(AnraOre)), new HarvestResource(119.0, 119.0, 119.0, "You dig some Crystal ore and put it in your backpack.", typeof(CrystalOre)), new HarvestResource(122.0, 122.0, 122.0, "You dig some Doom ore and put it in your backpack.", typeof(DoomOre)), new HarvestResource(125.0, 125.0, 125.0, "You dig some Goddess ore and put it in your backpack.", typeof(GoddessOre)), new HarvestResource(129.0, 129.0, 129.0, "You dig some New Zulu ore and put it in your backpack.", typeof(NewZuluOre)), new HarvestResource(130.0, 130.0, 130.0, "You dig some Dark Sable Ruby ore and put it in your backpack.", typeof(DarkSableRubyOre)), new HarvestResource(130.0, 130.0, 130.0, "You dig some Ebon Twilight Sapphire ore and put it in your backpack.", typeof(EbonTwilightSapphireOre)), new HarvestResource(140.0, 140.0, 140.0, "You dig some Radiant Nimbus Diamond ore and put it in your backpack.", typeof(RadiantNimbusDiamondOre)), }; veins = new[] { new HarvestVein(49.6, 0.0, res[0], null), // Iron new HarvestVein(11.2, 0.5, res[1], res[0]), // Gold new HarvestVein(09.8, 0.5, res[2], res[0]), // Spike new HarvestVein(08.4, 0.5, res[4], res[0]), // Fruity new HarvestVein(07.0, 0.5, res[5], res[0]), // Bronze new HarvestVein(05.6, 0.5, res[6], res[0]), // IceRock new HarvestVein(04.2, 0.5, res[7], res[0]), // BlackDwarf new HarvestVein(02.8, 0.5, res[8], res[0]), // DullCopper new HarvestVein(01.4, 0.5, res[9], res[0]), // Platinum new HarvestVein(0.1, 0.5, res[10], res[0]), // SilverRock new HarvestVein(0.1, 0.5, res[11], res[0]), // DarkPagan new HarvestVein(0.1, 0.5, res[12], res[0]), // Copper new HarvestVein(0.1, 0.5, res[13], res[0]), // Mystic new HarvestVein(0.1, 0.5, res[14], res[0]), // Spectral new HarvestVein(0.1, 0.5, res[15], res[0]), // OldBritain new HarvestVein(0.1, 0.5, res[16], res[0]), // Onyx new HarvestVein(0.1, 0.5, res[17], res[0]), // RedElven new HarvestVein(0.1, 0.5, res[18], res[0]), // Undead new HarvestVein(0.1, 0.5, res[19], res[0]), // Pyrite new HarvestVein(0.1, 0.5, res[20], res[0]), // Virginity new HarvestVein(0.1, 0.5, res[21], res[0]), // Malachite new HarvestVein(0.1, 0.5, res[22], res[0]), // Lavarock new HarvestVein(0.1, 0.5, res[23], res[0]), // Azurite new HarvestVein(0.1, 0.5, res[24], res[0]), // Dripstone new HarvestVein(0.1, 0.5, res[24], res[0]), // Executor new HarvestVein(0.1, 0.5, res[25], res[0]), // Peachblue new HarvestVein(0.1, 0.5, res[26], res[0]), // Destruction new HarvestVein(0.1, 0.5, res[27], res[0]), // Anra new HarvestVein(0.1, 0.5, res[28], res[0]), // Crystal new HarvestVein(0.1, 0.5, res[29], res[0]), // Doom new HarvestVein(0.1, 0.5, res[30], res[0]), // Goddess new HarvestVein(0.1, 0.5, res[31], res[0]), // NewZulu new HarvestVein(0.1, 0.5, res[32], res[0]), // DarkSableRuby new HarvestVein(0.1, 0.5, res[33], res[0]), // EbonTwilightSapphire new HarvestVein(0.1, 0.5, res[34], res[0]), // RadiantNimbusDiamond }; oreAndStone.Resources = res; oreAndStone.Veins = veins; oreAndStone.RaceBonus = false; oreAndStone.RandomizeVeins = false; Definitions.Add(oreAndStone); #endregion }
public ROSIntegration(ReadOnlyTargetRules Target) : base(Target) { PCHUsage = ModuleRules.PCHUsageMode.UseExplicitOrSharedPCHs; string BSONPath = Path.Combine(ThirdPartyPath, "bson"); // Console.WriteLine(""); Console.WriteLine("BSONPath: " + BSONPath); // Include std::string functions for rapidjson Definitions.Add("RAPIDJSON_HAS_STDSTRING=1"); PublicIncludePaths.AddRange( new string[] { "ROSIntegration/Public" // ... add public include paths required here ... } ); PrivateIncludePaths.AddRange( new string[] { "ROSIntegration/Private", "ROSIntegration/Private/rosbridge2cpp" // ... 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", "Slate", "SlateCore", "Sockets", "Networking" // ... 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) { Console.WriteLine("Using Windows BSON files"); PublicAdditionalLibraries.Add(Path.Combine(BSONPath, "lib", "bson-static-1.0.lib")); PublicIncludePaths.Add(Path.Combine(BSONPath, "include", "windows")); } }
private HerbGathering() { HarvestResource[] res; HarvestVein[] veins; #region HerbGathering HarvestDefinition herbs = new HarvestDefinition(); // Resource banks are every 4x3 tiles herbs.BankWidth = 1; herbs.BankHeight = 1; // Every bank holds from 20 to 45 logs herbs.MinTotal = 2; herbs.MaxTotal = 8; // A resource bank will respawn its content every 20 to 30 minutes herbs.MinRespawn = TimeSpan.FromMinutes(30.0); herbs.MaxRespawn = TimeSpan.FromMinutes(60.0); // Skill checking is done on the Camping skill herbs.Skill = SkillName.Camping; // Set the list of harvestable tiles herbs.Tiles = m_PlantTiles; // Players must be within 2 tiles to harvest herbs.MaxRange = 2; // Ten logs per harvest action herbs.ConsumedPerHarvest = 2; herbs.ConsumedPerFeluccaHarvest = 2; // The chopping effect herbs.EffectActions = new int[] { 13 }; herbs.EffectSounds = new int[] { 0x13E }; herbs.EffectCounts = (Core.AOS ? new int[] { 1 } : new int[] { 1, 2, 2, 2, 3 }); herbs.EffectDelay = TimeSpan.FromSeconds(1.6); herbs.EffectSoundDelay = TimeSpan.FromSeconds(0.9); herbs.NoResourcesMessage = "There's not enough herbs left to harvest."; // There's not enough wood here to harvest. herbs.FailMessage = "You fail to find any usable herbs."; // You hack at the tree for a while, but fail to produce any useable wood. herbs.OutOfRangeMessage = 500446; // That is too far away. herbs.PackFullMessage = "You can't place any more herbs in your pack."; // You can't place any wood into your backpack! herbs.ToolBrokeMessage = "You broke your sickle."; // You broke your axe. var common = "You find some common herbs."; res = new HarvestResource[] { new HarvestResource(00.0, 00.0, 100.0, common, typeof(BlackPearl)), new HarvestResource(00.0, 00.0, 100.0, common, typeof(Bloodmoss)), new HarvestResource(00.0, 00.0, 100.0, common, typeof(Garlic)), new HarvestResource(00.0, 00.0, 100.0, common, typeof(Ginseng)), new HarvestResource(00.0, 00.0, 100.0, common, typeof(MandrakeRoot)), new HarvestResource(00.0, 00.0, 100.0, common, typeof(Nightshade)), new HarvestResource(00.0, 00.0, 100.0, common, typeof(SpidersSilk)), new HarvestResource(00.0, 00.0, 100.0, common, typeof(SulfurousAsh)), new HarvestResource(99.9, 60.0, 140.0, "You find some batwings.", typeof(BatWing)), new HarvestResource(99.9, 60.0, 140.0, "You find some eyes of newt.", typeof(EyeOfNewt)), }; veins = new HarvestVein[] { new HarvestVein(10.0, 0.0, res[0], null), new HarvestVein(10.0, 0.5, res[1], res[0]), new HarvestVein(10.0, 0.5, res[2], res[0]), new HarvestVein(10.0, 0.5, res[3], res[0]), new HarvestVein(10.0, 0.5, res[4], res[0]), new HarvestVein(10.0, 0.5, res[5], res[0]), new HarvestVein(10.0, 0.5, res[6], res[0]), new HarvestVein(10.0, 0.5, res[7], res[0]), new HarvestVein(10.0, 0.5, res[8], res[0]), new HarvestVein(10.0, 0.5, res[9], res[0]), }; herbs.BonusResources = new BonusHarvestResource[] { new BonusHarvestResource(0, 83.9, null, null), //Nothing //new BonusHarvestResource( 100, 10.0, 1072548, typeof( CommonSeeds ) ), new BonusHarvestResource(100, 03.0, 1072550, typeof(Seed)), //new BonusHarvestResource( 100, 02.0, 1072547, typeof( UnCommonSeeds ) ), new BonusHarvestResource(100, 01.0, 1072549, typeof(ParasiticPlant)), //new BonusHarvestResource( 100, 00.1, 1072551, typeof( ExoticSeeds ) ) }; herbs.Resources = res; herbs.Veins = veins; herbs.RaceBonus = false; herbs.RandomizeVeins = false; m_Definition = herbs; Definitions.Add(herbs); #endregion }
private Mining() { HarvestResource[] res; HarvestVein[] veins; #region Mining for ore and stone HarvestDefinition oreAndStone = m_OreAndStone = new HarvestDefinition(); // Resource banks are every 8x8 tiles oreAndStone.BankWidth = 8; oreAndStone.BankHeight = 8; // Every bank holds from 10 to 34 ore oreAndStone.MinTotal = 10; oreAndStone.MaxTotal = 34; // A resource bank will respawn its content every 10 to 20 minutes oreAndStone.MinRespawn = TimeSpan.FromMinutes(10.0); oreAndStone.MaxRespawn = TimeSpan.FromMinutes(20.0); // Skill checking is done on the Mining skill oreAndStone.Skill = SkillName.Mining; // Set the list of harvestable tiles oreAndStone.Tiles = m_MountainAndCaveTiles; // Players must be within 2 tiles to harvest oreAndStone.MaxRange = 2; // One ore per harvest action oreAndStone.ConsumedPerHarvest = 1; oreAndStone.ConsumedPerFeluccaHarvest = 2; // The digging effect oreAndStone.EffectActions = new int[] { 11 }; oreAndStone.EffectSounds = new int[] { 0x125, 0x126 }; oreAndStone.EffectCounts = new int[] { 1 }; oreAndStone.EffectDelay = TimeSpan.FromSeconds(1.6); oreAndStone.EffectSoundDelay = TimeSpan.FromSeconds(0.9); oreAndStone.NoResourcesMessage = 503040; // There is no metal here to mine. oreAndStone.DoubleHarvestMessage = 503042; // Someone has gotten to the metal before you. oreAndStone.TimedOutOfRangeMessage = 503041; // You have moved too far away to continue mining. oreAndStone.OutOfRangeMessage = 500446; // That is too far away. oreAndStone.FailMessage = 503043; // You loosen some rocks but fail to find any useable ore. oreAndStone.PackFullMessage = 1010481; // Your backpack is full, so the ore you mined is lost. oreAndStone.ToolBrokeMessage = 1044038; // You have worn out your tool! res = new HarvestResource[] { new HarvestResource(00.0, 00.0, 100.0, 1007072, typeof(IronOre), typeof(Granite), typeof(Amber)), new HarvestResource(65.0, 25.0, 105.0, 1007073, typeof(DullCopperOre), typeof(DullCopperGranite), typeof(Citrine), typeof(DullCopperElemental)), new HarvestResource(70.0, 30.0, 110.0, 1007074, typeof(ShadowIronOre), typeof(ShadowIronGranite), typeof(Tourmaline), typeof(ShadowIronElemental)), new HarvestResource(75.0, 35.0, 115.0, 1007075, typeof(CopperOre), typeof(CopperGranite), typeof(Ruby), typeof(CopperElemental)), new HarvestResource(80.0, 40.0, 120.0, 1007076, typeof(BronzeOre), typeof(BronzeGranite), typeof(Amethyst), typeof(BronzeElemental)), new HarvestResource(85.0, 45.0, 125.0, 1007077, typeof(GoldOre), typeof(GoldGranite), typeof(Sapphire), typeof(GoldenElemental)), new HarvestResource(90.0, 50.0, 130.0, 1007078, typeof(AgapiteOre), typeof(AgapiteGranite), typeof(Emerald), typeof(AgapiteElemental)), new HarvestResource(95.0, 55.0, 135.0, 1007079, typeof(VeriteOre), typeof(VeriteGranite), typeof(StarSapphire), typeof(VeriteElemental)), new HarvestResource(99.0, 59.0, 139.0, 1007080, typeof(ValoriteOre), typeof(ValoriteGranite), typeof(Diamond), typeof(ValoriteElemental)) }; veins = new HarvestVein[] { new HarvestVein(49.6, 0.0, res[0], null), // Iron new HarvestVein(11.2, 0.5, res[1], res[0]), // Dull Copper new HarvestVein(09.8, 0.5, res[2], res[0]), // Shadow Iron new HarvestVein(08.4, 0.5, res[3], res[0]), // Copper new HarvestVein(07.0, 0.5, res[4], res[0]), // Bronze new HarvestVein(05.6, 0.5, res[5], res[0]), // Gold new HarvestVein(04.2, 0.5, res[6], res[0]), // Agapite new HarvestVein(02.8, 0.5, res[7], res[0]), // Verite new HarvestVein(01.4, 0.5, res[8], res[0]) // Valorite }; oreAndStone.Resources = res; oreAndStone.Veins = veins; if (Core.ML) { oreAndStone.BonusResources = new BonusHarvestResource[] { new BonusHarvestResource(0, 99.4, null, null), //Nothing new BonusHarvestResource(100, .1, 1072562, typeof(BlueDiamond)), new BonusHarvestResource(100, .1, 1072567, typeof(DarkSapphire)), new BonusHarvestResource(100, .1, 1072570, typeof(EcruCitrine)), new BonusHarvestResource(100, .1, 1072564, typeof(FireRuby)), new BonusHarvestResource(100, .1, 1072566, typeof(PerfectEmerald)), new BonusHarvestResource(100, .1, 1072568, typeof(Turquoise)) }; } oreAndStone.RaceBonus = Core.ML; oreAndStone.RandomizeVeins = Core.ML; Definitions.Add(oreAndStone); #endregion #region Mining for sand HarvestDefinition sand = m_Sand = new HarvestDefinition(); // Resource banks are every 8x8 tiles sand.BankWidth = 8; sand.BankHeight = 8; // Every bank holds from 6 to 12 sand sand.MinTotal = 6; sand.MaxTotal = 12; // A resource bank will respawn its content every 10 to 20 minutes sand.MinRespawn = TimeSpan.FromMinutes(10.0); sand.MaxRespawn = TimeSpan.FromMinutes(20.0); // Skill checking is done on the Mining skill sand.Skill = SkillName.Mining; // Set the list of harvestable tiles sand.Tiles = m_SandTiles; // Players must be within 2 tiles to harvest sand.MaxRange = 2; // One sand per harvest action sand.ConsumedPerHarvest = 1; sand.ConsumedPerFeluccaHarvest = 1; // The digging effect sand.EffectActions = new int[] { 11 }; sand.EffectSounds = new int[] { 0x125, 0x126 }; sand.EffectCounts = new int[] { 6 }; sand.EffectDelay = TimeSpan.FromSeconds(1.6); sand.EffectSoundDelay = TimeSpan.FromSeconds(0.9); sand.NoResourcesMessage = 1044629; // There is no sand here to mine. sand.DoubleHarvestMessage = 1044629; // There is no sand here to mine. sand.TimedOutOfRangeMessage = 503041; // You have moved too far away to continue mining. sand.OutOfRangeMessage = 500446; // That is too far away. sand.FailMessage = 1044630; // You dig for a while but fail to find any of sufficient quality for glassblowing. sand.PackFullMessage = 1044632; // Your backpack can't hold the sand, and it is lost! sand.ToolBrokeMessage = 1044038; // You have worn out your tool! res = new HarvestResource[] { new HarvestResource(100.0, 70.0, 400.0, 1044631, typeof(Sand)) }; veins = new HarvestVein[] { new HarvestVein(100.0, 0.0, res[0], null) }; sand.Resources = res; sand.Veins = veins; Definitions.Add(sand); #endregion }
public Core(ReadOnlyTargetRules Target) : base(Target) { PrivatePCHHeaderFile = "Private/CorePrivatePCH.h"; SharedPCHHeaderFile = "Public/CoreSharedPCH.h"; bAddDefaultIncludePaths = false; PublicIncludePaths.AddRange( new string[] { "Runtime/Core/Public", "Runtime/Core/Public/Internationalization", "Runtime/Core/Public/Async", "Runtime/Core/Public/Concurrency", "Runtime/Core/Public/Containers", "Runtime/Core/Public/Delegates", "Runtime/Core/Public/GenericPlatform", "Runtime/Core/Public/HAL", "Runtime/Core/Public/Logging", "Runtime/Core/Public/Math", "Runtime/Core/Public/Misc", "Runtime/Core/Public/Modules", "Runtime/Core/Public/Modules/Boilerplate", "Runtime/Core/Public/ProfilingDebugging", "Runtime/Core/Public/Serialization", "Runtime/Core/Public/Serialization/Csv", "Runtime/Core/Public/Stats", "Runtime/Core/Public/Templates", "Runtime/Core/Public/UObject", } ); PrivateIncludePaths.AddRange( new string[] { "Developer/DerivedDataCache/Public", "Runtime/SynthBenchmark/Public", "Runtime/Core/Private", "Runtime/Core/Private/Misc", "Runtime/Core/Private/Serialization/Json", "Runtime/Core/Private/Internationalization", "Runtime/Core/Private/Internationalization/Cultures", "Runtime/Analytics/Public", "Runtime/Engine/Public", } ); PrivateIncludePathModuleNames.AddRange( new string[] { "TargetPlatform", "DerivedDataCache", "InputDevice", "Analytics", "RHI" } ); if (UEBuildConfiguration.bBuildEditor == true) { DynamicallyLoadedModuleNames.Add("SourceCodeAccess"); PrivateIncludePathModuleNames.Add("DirectoryWatcher"); DynamicallyLoadedModuleNames.Add("DirectoryWatcher"); } if ((Target.Platform == UnrealTargetPlatform.Win64) || (Target.Platform == UnrealTargetPlatform.Win32)) { PublicIncludePaths.Add("Runtime/Core/Public/Windows"); AddEngineThirdPartyPrivateStaticDependencies(Target, "zlib"); AddEngineThirdPartyPrivateStaticDependencies(Target, "IntelTBB", "XInput" ); } else if (Target.Platform == UnrealTargetPlatform.Mac) { PublicIncludePaths.AddRange(new string[] { "Runtime/Core/Public/Apple", "Runtime/Core/Public/Mac" }); AddEngineThirdPartyPrivateStaticDependencies(Target, "IntelTBB", "zlib", "OpenGL", "PLCrashReporter" ); PublicFrameworks.AddRange(new string[] { "Cocoa", "Carbon", "IOKit", "Security" }); if (UEBuildConfiguration.bBuildEditor == true) { PublicAdditionalLibraries.Add("/System/Library/PrivateFrameworks/MultitouchSupport.framework/Versions/Current/MultitouchSupport"); } } else if (Target.Platform == UnrealTargetPlatform.IOS || Target.Platform == UnrealTargetPlatform.TVOS) { PublicIncludePaths.AddRange(new string[] { "Runtime/Core/Public/Apple", "Runtime/Core/Public/IOS" }); AddEngineThirdPartyPrivateStaticDependencies(Target, "zlib" ); PublicFrameworks.AddRange(new string[] { "UIKit", "Foundation", "AudioToolbox", "AVFoundation", "GameKit", "StoreKit", "CoreVideo", "CoreMedia", "CoreGraphics", "GameController", "SystemConfiguration" }); if (Target.Platform == UnrealTargetPlatform.IOS) { PublicFrameworks.AddRange(new string[] { "CoreMotion", "AdSupport" }); AddEngineThirdPartyPrivateStaticDependencies(Target, "PLCrashReporter" ); } bool bSupportAdvertising = Target.Platform == UnrealTargetPlatform.IOS; if (bSupportAdvertising) { PublicFrameworks.AddRange(new string[] { "iAD" }); } } else if (Target.Platform == UnrealTargetPlatform.Android) { PublicIncludePaths.Add("Runtime/Core/Public/Android"); AddEngineThirdPartyPrivateStaticDependencies(Target, "cxademangle", "zlib" ); } else if ((Target.Platform == UnrealTargetPlatform.Linux)) { PublicIncludePaths.Add("Runtime/Core/Public/Linux"); AddEngineThirdPartyPrivateStaticDependencies(Target, "zlib", "jemalloc", "elftoolchain", "SDL2" ); // Core uses dlopen() PublicAdditionalLibraries.Add("dl"); // We need FreeType2 and GL for the Splash, but only in the Editor if (Target.Type == TargetType.Editor) { AddEngineThirdPartyPrivateStaticDependencies(Target, "FreeType2"); AddEngineThirdPartyPrivateStaticDependencies(Target, "OpenGL"); PrivateIncludePathModuleNames.Add("ImageWrapper"); } } else if (Target.Platform == UnrealTargetPlatform.HTML5 && Target.Architecture == "-win32") { PublicIncludePaths.Add("Runtime/Core/Public/HTML5"); AddEngineThirdPartyPrivateStaticDependencies(Target, "SDL2"); AddEngineThirdPartyPrivateStaticDependencies(Target, "OpenAL"); } else if (Target.Platform == UnrealTargetPlatform.HTML5 && Target.Architecture != "-win32") { AddEngineThirdPartyPrivateStaticDependencies(Target, "SDL2"); PrivateDependencyModuleNames.Add("HTML5JS"); PrivateDependencyModuleNames.Add("MapPakDownloader"); } else if (Target.Platform == UnrealTargetPlatform.PS4) { PublicAdditionalLibraries.Add("SceRtc_stub_weak"); //ORBIS SDK rtc.h, used in PS4Time.cpp } if (UEBuildConfiguration.bCompileICU == true) { AddEngineThirdPartyPrivateStaticDependencies(Target, "ICU"); } Definitions.Add("UE_ENABLE_ICU=" + (UEBuildConfiguration.bCompileICU ? "1" : "0")); // Enable/disable (=1/=0) ICU usage in the codebase. NOTE: This flag is for use while integrating ICU and will be removed afterward. // If we're compiling with the engine, then add Core's engine dependencies if (UEBuildConfiguration.bCompileAgainstEngine == true) { if (!UEBuildConfiguration.bBuildRequiresCookedData) { DynamicallyLoadedModuleNames.AddRange(new string[] { "DerivedDataCache" }); } } // On Windows platform, VSPerfExternalProfiler.cpp needs access to "VSPerf.h". This header is included with Visual Studio, but it's not in a standard include path. if (Target.Platform == UnrealTargetPlatform.Win32 || Target.Platform == UnrealTargetPlatform.Win64) { var VisualStudioVersionNumber = "11.0"; var SubFolderName = (Target.Platform == UnrealTargetPlatform.Win64) ? "x64/PerfSDK" : "PerfSDK"; string PerfIncludeDirectory = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ProgramFilesX86), String.Format("Microsoft Visual Studio {0}/Team Tools/Performance Tools/{1}", VisualStudioVersionNumber, SubFolderName)); if (File.Exists(Path.Combine(PerfIncludeDirectory, "VSPerf.h"))) { PrivateIncludePaths.Add(PerfIncludeDirectory); Definitions.Add("WITH_VS_PERF_PROFILER=1"); } else { Definitions.Add("WITH_VS_PERF_PROFILER=0"); } } if (Target.Platform == UnrealTargetPlatform.Win32 || Target.Platform == UnrealTargetPlatform.Win64) { WhitelistRestrictedFolders.Add("Private/Windows/NoRedist"); } if (Target.Platform == UnrealTargetPlatform.XboxOne) { Definitions.Add("WITH_DIRECTXMATH=1"); } else if ((Target.Platform == UnrealTargetPlatform.Win64) || (Target.Platform == UnrealTargetPlatform.Win32)) { // To enable this requires Win8 SDK Definitions.Add("WITH_DIRECTXMATH=0"); // Enable to test on Win64/32. //PublicDependencyModuleNames.AddRange( // Enable to test on Win64/32. // new string[] { // "DirectXMath" //}); } else { Definitions.Add("WITH_DIRECTXMATH=0"); } }
public AgogCore(ReadOnlyTargetRules Target) : base(Target) { // Ignore warnings about hokey code in windows.h bEnableUndefinedIdentifierWarnings = false; // Check if Sk source code is present (Pro-RT license) var bFullSource = File.Exists(Path.Combine(ModuleDirectory, "..", "SkookumScript", "Private", "SkookumScript", "Sk.cpp")); // Allow packaging script to force a lib build by creating a temp file (Agog Labs internal) bFullSource = bFullSource && !File.Exists(Path.Combine(ModuleDirectory, "..", "SkookumScript", "force-lib-build.txt")); // If full source is present, build module from source, otherwise link with binary library Type = bFullSource ? ModuleType.CPlusPlus : ModuleType.External; // Enable fussy level of checking (Agog Labs internal) ExternalDependencies.Add("enable-mad-check.txt"); var bMadCheck = File.Exists(Path.Combine(ModuleDirectory, "enable-mad-check.txt")); if (bMadCheck) { Definitions.Add("A_MAD_CHECK"); } // Add user define if exists (Agog Labs internal) ExternalDependencies.Add("mad-define.txt"); var userDefineFilePath = Path.Combine(ModuleDirectory, "mad-define.txt"); if (File.Exists(userDefineFilePath)) { var userDefine = File.ReadAllText(userDefineFilePath).Trim(); if (userDefine.Length > 0) { Definitions.Add(userDefine); } } var bPlatformAllowed = false; List <string> platPathSuffixes = new List <string>(); string libNameExt = ".a"; string libNamePrefix = "lib"; string libNameSuffix = ""; string platformName = ""; bool useDebugCRT = Target.bDebugBuildsActuallyUseDebugCRT; switch (Target.Platform) { case UnrealTargetPlatform.Win32: case UnrealTargetPlatform.Win64: bPlatformAllowed = true; platformName = Target.Platform == UnrealTargetPlatform.Win64 ? "Win64" : "Win32"; platPathSuffixes.Add(Path.Combine(platformName, Target.WindowsPlatform.Compiler == WindowsCompiler.VisualStudio2015 ? "VS2015" : "VS2013")); libNameExt = ".lib"; libNamePrefix = ""; break; case UnrealTargetPlatform.Mac: bPlatformAllowed = true; platformName = "Mac"; platPathSuffixes.Add(platformName); useDebugCRT = true; Definitions.Add("A_PLAT_OSX"); // On Mac, in library mode, always assume DLL since libs are universal for both dylib and static builds if (!bFullSource) { Definitions.Add("A_IS_DLL"); } break; case UnrealTargetPlatform.Linux: bPlatformAllowed = true; platformName = "Linux"; platPathSuffixes.Add(platformName); useDebugCRT = true; Definitions.Add("A_PLAT_LINUX64"); //UEBuildConfiguration.bForceEnableExceptions = true; break; case UnrealTargetPlatform.IOS: bPlatformAllowed = true; platformName = "IOS"; platPathSuffixes.Add(platformName); useDebugCRT = true; Definitions.Add("A_PLAT_iOS"); break; case UnrealTargetPlatform.TVOS: bPlatformAllowed = true; platformName = "TVOS"; platPathSuffixes.Add(platformName); useDebugCRT = true; Definitions.Add("A_PLAT_tvOS"); break; case UnrealTargetPlatform.Android: bPlatformAllowed = true; platformName = "Android"; platPathSuffixes.Add(Path.Combine(platformName, "ARM")); platPathSuffixes.Add(Path.Combine(platformName, "ARM64")); platPathSuffixes.Add(Path.Combine(platformName, "x86")); platPathSuffixes.Add(Path.Combine(platformName, "x64")); useDebugCRT = true; Definitions.Add("A_PLAT_ANDROID"); break; case UnrealTargetPlatform.XboxOne: bPlatformAllowed = bFullSource; platformName = "XONE"; Definitions.Add("A_PLAT_X_ONE"); break; case UnrealTargetPlatform.PS4: bPlatformAllowed = bFullSource; platformName = "PS4"; Definitions.Add("A_PLAT_PS4"); break; } // NOTE: All modules inside the SkookumScript plugin folder must use the exact same definitions! switch (Target.Configuration) { case UnrealTargetConfiguration.Debug: case UnrealTargetConfiguration.DebugGame: libNameSuffix = useDebugCRT ? "-Debug" : "-DebugCRTOpt"; Definitions.Add("A_EXTRA_CHECK=1"); Definitions.Add("A_UNOPTIMIZED=1"); break; case UnrealTargetConfiguration.Development: case UnrealTargetConfiguration.Test: libNameSuffix = "-Development"; Definitions.Add("A_EXTRA_CHECK=1"); break; case UnrealTargetConfiguration.Shipping: libNameSuffix = "-Shipping"; Definitions.Add("A_SYMBOL_STR_DB=1"); Definitions.Add("A_NO_SYMBOL_REF_LINK=1"); break; } // Determine if monolithic build var bIsMonolithic = (Target.LinkType == TargetLinkType.Monolithic); if (!bIsMonolithic) { Definitions.Add("A_IS_DLL"); } // Public include paths PublicIncludePaths.Add(Path.Combine(ModuleDirectory, "Public")); if (bFullSource) { // We're building SkookumScript from source - not much else needed PrivateIncludePaths.Add(Path.Combine(ModuleDirectory, "Private")); } else if (bPlatformAllowed) { var moduleName = "AgogCore"; // Link with monolithic library on all platforms except UE4Editor Win64 which requires a specific DLL import library var libFileNameStem = libNamePrefix + moduleName + ((!bIsMonolithic && Target.Platform == UnrealTargetPlatform.Win64) ? "-" + platformName : "") + libNameSuffix; var libFileName = libFileNameStem + libNameExt; var libDirPathBase = Path.Combine(ModuleDirectory, "Lib"); // Add library paths to linker parameters foreach (var platPathSuffix in platPathSuffixes) { var libDirPath = Path.Combine(libDirPathBase, platPathSuffix); var libFilePath = Path.Combine(libDirPath, libFileName); PublicLibraryPaths.Add(libDirPath); // For non-Android, add full path if (Target.Platform != UnrealTargetPlatform.Android) { PublicAdditionalLibraries.Add(libFilePath); } } // For Android, just add core of library name, e.g. "SkookumScript-Development" if (Target.Platform == UnrealTargetPlatform.Android) { PublicAdditionalLibraries.Add(moduleName + libNameSuffix); } } }
public IOSApsalar(TargetInfo Target) { BinariesSubFolder = "NotForLicensees"; PublicDependencyModuleNames.AddRange( new string[] { "Core", // ... add other public dependencies that you statically link with here ... } ); PrivateDependencyModuleNames.AddRange( new string[] { "Analytics", // ... add private dependencies that you statically link with here ... } ); PublicIncludePathModuleNames.Add("Analytics"); PublicFrameworks.AddRange( new string[] { "CoreTelephony", "SystemConfiguration", "UIKit", "Foundation", "CoreGraphics", "MobileCoreServices", "StoreKit", "CFNetwork", "CoreData", "Security", "CoreLocation" }); PublicAdditionalLibraries.AddRange( new string[] { "sqlite3", "z" }); bool bHasApsalarSDK = (System.IO.Directory.Exists(System.IO.Path.Combine(UEBuildConfiguration.UEThirdPartySourceDirectory, "Apsalar")) && System.IO.Directory.Exists(System.IO.Path.Combine(UEBuildConfiguration.UEThirdPartySourceDirectory, "Apsalar", "IOS"))) || (System.IO.Directory.Exists(System.IO.Path.Combine(UEBuildConfiguration.UEThirdPartySourceDirectory, "NotForLicensees")) && System.IO.Directory.Exists(System.IO.Path.Combine(UEBuildConfiguration.UEThirdPartySourceDirectory, "NotForLicensees", "Apsalar")) && System.IO.Directory.Exists(System.IO.Path.Combine(UEBuildConfiguration.UEThirdPartySourceDirectory, "NotForLicensees", "Apsalar", "IOS"))); if (bHasApsalarSDK) { PublicIncludePaths.Add(UEBuildConfiguration.UEThirdPartySourceDirectory + "NotForLicensees/Apsalar/IOS/"); PublicAdditionalLibraries.Add(UEBuildConfiguration.UEThirdPartySourceDirectory + "NotForLicensees/Apsalar/IOS/libApsalar.a"); Definitions.Add("WITH_APSALAR=1"); } else { Definitions.Add("WITH_APSALAR=0"); } }