Inheritance: MonoBehaviour
	public override void SetupGlobalEnvironment(
		TargetInfo Target,
		ref LinkEnvironmentConfiguration OutLinkEnvironmentConfiguration,
		ref CPPEnvironmentConfiguration OutCPPEnvironmentConfiguration
		)
	{
		// Turn off various third party features we don't need

		// Currently we force Lean and Mean mode
		UEBuildConfiguration.bCompileLeanAndMeanUE = true;

		// Currently this app is not linking against the engine, so we'll compile out references from Core to the rest of the engine
		UEBuildConfiguration.bCompileAgainstEngine = false;
		UEBuildConfiguration.bCompileAgainstCoreUObject = false;
		UEBuildConfiguration.bBuildWithEditorOnlyData = true;

		// Never use malloc profiling in ShaderCompileWorker.
		BuildConfiguration.bUseMallocProfiler = false;

		// Force all shader formats to be built and included.
        UEBuildConfiguration.bForceBuildShaderFormats = true;

		// ShaderCompileWorker is a console application, not a Windows app (sets entry point to main(), instead of WinMain())
		OutLinkEnvironmentConfiguration.bIsBuildingConsoleApplication = true;

		// Disable logging, as the workers are spawned often and logging will just slow them down
		OutCPPEnvironmentConfiguration.Definitions.Add("ALLOW_LOG_FILE=0");

        // Linking against wer.lib/wer.dll causes XGE to bail when the worker is run on a Windows 8 machine, so turn this off.
        OutCPPEnvironmentConfiguration.Definitions.Add("ALLOW_WINDOWS_ERROR_REPORT_LIB=0");
	}
    public OneSkyLocalizationService(TargetInfo Target)
	{
        PrivateDependencyModuleNames.AddRange(
            new string[] {
				"Core",
				"CoreUObject",
                "InputCore",
				"Slate",
				"SlateCore",
                "EditorStyle",
                "LocalizationService",
                "Json",
                "Internationalization",
                "HTTP",
                "Serialization",
			}
		);

        PrivateIncludePathModuleNames.AddRange(
            new string[] {
				"LocalizationService",
				"Json",
                "Internationalization",
				"HTTP",
			}
        );
	}
	public ScreenShotComparisonTools(TargetInfo Target)
	{
		PublicDependencyModuleNames.AddRange(
			new string[] {
				"Core",
				"CoreUObject",
			}
		);

		PrivateDependencyModuleNames.AddRange(
			new string[] {
				"AutomationMessages",
				"UnrealEdMessages",
				"Slate",
                "EditorStyle",
				"ImageWrapper",
				"Json",
				"JsonUtilities"
			}
		);

		PrivateIncludePathModuleNames.AddRange(
			new string[] {
				"Messaging"
			}
		);

		PrivateIncludePaths.AddRange(
			new string[] {
				"Developer/ScreenShotComparisonTools/Private"
			}
		);
	}
Ejemplo n.º 4
0
        public bool LoadHydraLib(TargetInfo Target)
        {
            bool isLibrarySupported = false;

            if ((Target.Platform == UnrealTargetPlatform.Win64) || (Target.Platform == UnrealTargetPlatform.Win32))
            {
                isLibrarySupported = true;

                string PlatformString = (Target.Platform == UnrealTargetPlatform.Win64) ? "x64" : "x32";
                string LibrariesPath = Path.Combine(ThirdPartyPath, "Sixense", "Lib");

                //Lib based bind unsupported due to sixense wrong lib version compile, limiting platforms to windows 32/64
                //PublicAdditionalLibraries.Add(Path.Combine(LibrariesPath, "sixense_s_" + PlatformString + ".lib"));
            }

            if (isLibrarySupported)
            {
                // Include path
                PublicIncludePaths.Add(Path.Combine(ThirdPartyPath, "Sixense", "Include"));
            }

            //Definitions.Add(string.Format("WITH_HYDRA_BINDING={0}", isLibrarySupported ? 1 : 0));

            return isLibrarySupported;
        }
	public SceneOutliner(TargetInfo Target)
	{
		PrivateIncludePathModuleNames.AddRange(
			new string[] {
			}
		);

		PrivateDependencyModuleNames.AddRange(
			new string[] {
				"Core", 
				"CoreUObject",
				"Engine", 
				"InputCore",
				"Slate", 
				"SlateCore",
				"EditorStyle",
				"UnrealEd",
			}
		);

		PrivateIncludePathModuleNames.AddRange(
			new string[] {
				"LevelEditor"
			}
		);
	}
Ejemplo n.º 6
0
        public CodeView(TargetInfo Target)
        {
            PublicDependencyModuleNames.AddRange(
                new string[]
                {
                    "Slate",
                    "InputCore",
                    "Core",
                    "CoreUObject",
                    "Engine",
                    "UnrealEd",
                    "EditorStyle",
                    "PropertyEditor",
                    "DesktopPlatform",
                }
            );

            PrivateDependencyModuleNames.AddRange(
                new string[]
                {
                    "DetailCustomizations",
                    "SlateCore",
                }
            );
        }
    public override void SetupGlobalEnvironment(
		TargetInfo Target,
		ref LinkEnvironmentConfiguration OutLinkEnvironmentConfiguration,
		ref CPPEnvironmentConfiguration OutCPPEnvironmentConfiguration
		)
    {
        UEBuildConfiguration.bCompileNetworkProfiler = false;

        // Lean and mean
        UEBuildConfiguration.bCompileLeanAndMeanUE = true;

        // Never use malloc profiling in Unreal Header Tool.  We set this because often UHT is compiled right before the engine
        // automatically by Unreal Build Tool, but if bUseMallocProfiler is defined, UHT can operate incorrectly.
        BuildConfiguration.bUseMallocProfiler = false;

        // No editor needed
        UEBuildConfiguration.bBuildEditor = false;
        // Editor-only data, however, is needed
        UEBuildConfiguration.bBuildWithEditorOnlyData = true;

        // Currently this app is not linking against the engine, so we'll compile out references from Core to the rest of the engine
        UEBuildConfiguration.bCompileAgainstEngine = false;
        UEBuildConfiguration.bCompileAgainstCoreUObject = false;

        // UnrealHeaderTool is a console application, not a Windows app (sets entry point to main(), instead of WinMain())
        OutLinkEnvironmentConfiguration.bIsBuildingConsoleApplication = true;
    }
    public MeshUtilities(TargetInfo Target)
    {
        PrivateDependencyModuleNames.AddRange(
            new string [] {
                "Core",
                "CoreUObject",
                "Engine",
                "RawMesh",
                "RenderCore", // For FPackedNormal
                "Slate",      // For FSlateTextureAtlas
                "SlateCore",
                "UnrealEd",
            }
        );

        AddThirdPartyPrivateStaticDependencies(Target, "nvTriStrip");
        AddThirdPartyPrivateStaticDependencies(Target, "ForsythTriOptimizer");
        AddThirdPartyPrivateStaticDependencies(Target, "MeshSimplifier");

        if ((Target.Platform == UnrealTargetPlatform.Win64) || (Target.Platform == UnrealTargetPlatform.Win32))
        {
            AddThirdPartyPrivateStaticDependencies(Target, "DX9");
        }

        if (UEBuildConfiguration.bCompileSimplygon == true)
        {
            AddThirdPartyPrivateDynamicDependencies(Target, "SimplygonMeshReduction");
        }
    }
Ejemplo n.º 9
0
    public DirectShow(TargetInfo Target)
    {
        Type = ModuleType.External;

        if ((Target.Platform == UnrealTargetPlatform.Win64) ||
            (Target.Platform == UnrealTargetPlatform.Win32))
        {

            string DirectShowLibPath = UEBuildConfiguration.UEThirdPartySourceDirectory
                + "DirectShow/DirectShow-1.0.0/Lib/" + ((Target.Platform == UnrealTargetPlatform.Win32) ? "Win32" : "Win64") + "/vs" + WindowsPlatform.GetVisualStudioCompilerVersionName() + "/";

            PublicIncludePaths.Add(UEBuildConfiguration.UEThirdPartySourceDirectory + "DirectShow/DirectShow-1.0.0/src/Public");

            PublicLibraryPaths.Add( DirectShowLibPath );

            string LibraryName = "DirectShow";
            if (Target.Configuration == UnrealTargetConfiguration.Debug && BuildConfiguration.bDebugBuildsActuallyUseDebugCRT)
            {
                LibraryName += "d";
            }
            if (Target.Platform == UnrealTargetPlatform.Win64)
            {
                LibraryName += "_64";
            }
            LibraryName += ".lib";
            PublicAdditionalLibraries.Add(LibraryName);
        }
    }
Ejemplo n.º 10
0
    public override void SetupGlobalEnvironment(
		TargetInfo Target,
		ref LinkEnvironmentConfiguration OutLinkEnvironmentConfiguration,
		ref CPPEnvironmentConfiguration OutCPPEnvironmentConfiguration
		)
    {
        if( UnrealBuildTool.UnrealBuildTool.BuildingRocket() )
        {
            UEBuildConfiguration.bCompileLeanAndMeanUE = true;

            // Don't need editor or editor only data
            UEBuildConfiguration.bBuildEditor = false;
            UEBuildConfiguration.bBuildWithEditorOnlyData = false;

            UEBuildConfiguration.bCompileAgainstEngine = true;

            // Tag it as a Rocket build
            OutCPPEnvironmentConfiguration.Definitions.Add("UE_ROCKET=1");

            // no exports, so no need to verify that a .lib and .exp file was emitted by the linker.
            OutLinkEnvironmentConfiguration.bHasExports = false;
        }
        else
        {
            // Tag it as a UE4Game build
            OutCPPEnvironmentConfiguration.Definitions.Add("UE4GAME=1");
        }
    }
	public MovieSceneCaptureDialog(TargetInfo Target)
	{
		PrivateIncludePaths.AddRange(
			new string[] {
				"Editor/MovieSceneCaptureDialog/Private"
			}
		);

		PrivateDependencyModuleNames.AddRange(
			new string[] {
				"Core",
				"CoreUObject",
				"EditorStyle",
				"Engine",
				"InputCore",
				"Json",
				"JsonUtilities",
				"MovieScene",
				"MovieSceneCapture",
				"PropertyEditor",
				"SessionServices",
				"Slate",
				"SlateCore",
				"UnrealEd",
			}
		);

		PrivateIncludePathModuleNames.AddRange(
			new string[] {
				"LevelEditor"
			}
		);
	}
Ejemplo n.º 12
0
    public ClassViewer(TargetInfo Target)
    {
        PrivateIncludePathModuleNames.AddRange(
            new string[] {
                "AssetRegistry",
                "EditorWidgets",
                "PropertyEditor"
            }
        );

        PrivateDependencyModuleNames.AddRange(
            new string[] {
                "Core",
                "CoreUObject",
                "Engine",
                "InputCore",
                "Slate",
                "SlateCore",
                "EditorStyle",
                "UnrealEd",
                "PropertyEditor",
                "GameProjectGeneration"
            }
        );

        DynamicallyLoadedModuleNames.AddRange(
            new string[] {
                "AssetRegistry",
                "EditorWidgets",
                "PropertyEditor"
            }
        );
    }
        public BlockConstructorPlugin(TargetInfo Target)
		{

            PublicIncludePaths.AddRange(
                new string[] {
                "BlockConstructorPlugin/Public",
                "BlockConstructorPlugin/System",
                "BlockConstructorPlugin/UI"
            }
            );


            PrivateIncludePaths.AddRange(
                new string[] {
                "BlockConstructorPlugin/Private"
                }
               );


            PublicDependencyModuleNames.AddRange(
                new string[]
                {
                    "Engine",
                    "Core",
                    "CoreUObject",

                    "Slate",
                    "UnrealEd"
					// ... add other public dependencies that you statically link with here ...
				}
                );

            PrivateDependencyModuleNames.AddRange(
            new string[]
            {
                "Engine",
                "Projects",

                "CoreUObject",
                "InputCore",

                "UnrealEd",
                "LevelEditor",

                 "PropertyEditor",

                "Slate",
                "SlateCore"
				// ... add private dependencies that you statically link with here ...	
			}
            );


            DynamicallyLoadedModuleNames.AddRange(
				new string[]
				{
					// ... add any modules that your module loads dynamically here ...
				}
				);
		}
Ejemplo n.º 14
0
	public override void SetupGlobalEnvironment(
		TargetInfo Target,
		ref LinkEnvironmentConfiguration OutLinkEnvironmentConfiguration,
		ref CPPEnvironmentConfiguration OutCPPEnvironmentConfiguration
		)
	{
		// Lean and mean
		UEBuildConfiguration.bCompileLeanAndMeanUE = true;

		// Never use malloc profiling in Unreal Header Tool.  We set this because often UHT is compiled right before the engine
		// automatically by Unreal Build Tool, but if bUseMallocProfiler is defined, UHT can operate incorrectly.
		BuildConfiguration.bUseMallocProfiler = false;

		// No editor needed
		UEBuildConfiguration.bBuildEditor = false;
		// Editor-only data, however, is needed
		UEBuildConfiguration.bBuildWithEditorOnlyData = true;

		// Currently this app is not linking against the engine, so we'll compile out references from Core to the rest of the engine
		UEBuildConfiguration.bCompileAgainstEngine = false;

		// Force execption handling across all modules.
		UEBuildConfiguration.bForceEnableExceptions = true;

		// Plugin support
		UEBuildConfiguration.bCompileWithPluginSupport = true;
		UEBuildConfiguration.bBuildDeveloperTools = true;

		// UnrealHeaderTool is a console application, not a Windows app (sets entry point to main(), instead of WinMain())
		OutLinkEnvironmentConfiguration.bIsBuildingConsoleApplication = true;

		OutCPPEnvironmentConfiguration.Definitions.Add("HACK_HEADER_GENERATOR=1");
	}
        public AndroidDeviceProfileSelector(TargetInfo Target)
		{
			PublicIncludePaths.AddRange(
				new string[] {
                    "Runtime/AndroidDeviceProfileSelector/Public",
				}
				);

			PrivateIncludePaths.AddRange(
				new string[] {
					"Runtime/AndroidDeviceProfileSelector/Private",
				}
				);

			PublicDependencyModuleNames.AddRange(
				new string[]
				{
					"Core",
				}
				);

			PrivateDependencyModuleNames.AddRange(
				new string[]
				{
				    "Core",
				    "CoreUObject",
				    "Engine",
				}
				);
		}
Ejemplo n.º 16
0
	public override void SetupGlobalEnvironment(
		TargetInfo Target,
		ref LinkEnvironmentConfiguration OutLinkEnvironmentConfiguration,
		ref CPPEnvironmentConfiguration OutCPPEnvironmentConfiguration
		)
	{
	}
        public bool LoadLeapLib(TargetInfo Target)
        {
            bool isLibrarySupported = false;

            if ((Target.Platform == UnrealTargetPlatform.Win64) || (Target.Platform == UnrealTargetPlatform.Win32))
            {
                isLibrarySupported = true;

                string PlatformString = (Target.Platform == UnrealTargetPlatform.Win64) ? "Win64" : "Win32";

                PublicAdditionalLibraries.Add(Path.Combine(LibraryPath, PlatformString, "Leap.lib"));

                PublicDelayLoadDLLs.Add("Leap.dll");
                RuntimeDependencies.Add(new RuntimeDependency("$(EngineDir)/Binaries/ThirdParty/LeapMotion/" + Target.Platform.ToString() + "/" + "Leap.dll"));
            }
            else if (Target.Platform == UnrealTargetPlatform.Mac){

                isLibrarySupported = true;

                string PlatformString = "Mac";
                PublicAdditionalLibraries.Add(Path.Combine(BinariesPath, PlatformString, "libLeap.dylib"));

            }

            return isLibrarySupported;
        }
		public FluidSurface(TargetInfo Target)
		{
			PrivateIncludePaths.AddRange(
				new string[] {
					"FluidSurface/Private",
                    "FluidSurface/Private/Modifiers"
				}
				);

            PublicIncludePaths.AddRange(
                new string[] {
                    "FluidSurfaceRender/Public"
                }
                );

			PublicDependencyModuleNames.AddRange(
				new string[]
				{
					"Core",
					"CoreUObject",
                    "Engine",
                    "RenderCore",
                    "ShaderCore",
                    "RHI",
                    "FluidSurfaceEngine"
				}
				);
		}
Ejemplo n.º 19
0
    private bool LoadV8(TargetInfo Target)
    {
        if ((Target.Platform == UnrealTargetPlatform.Win64) || (Target.Platform == UnrealTargetPlatform.Win32))
        {
            string LibrariesPath = Path.Combine(ThirdPartyPath, "v8", "Libraries", "Windows");

            if (Target.Platform == UnrealTargetPlatform.Win64)
            {
                LibrariesPath = Path.Combine(LibrariesPath, "x64");
            }
            else
            {
                LibrariesPath = Path.Combine(LibrariesPath, "x86");
            }

            LibrariesPath = Path.Combine(LibrariesPath, "Release");

            PublicAdditionalLibraries.Add(Path.Combine(LibrariesPath, "icui18n.lib"));
            PublicAdditionalLibraries.Add(Path.Combine(LibrariesPath, "icuuc.lib"));
            PublicAdditionalLibraries.Add(Path.Combine(LibrariesPath, "v8_base.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"));
            PublicAdditionalLibraries.Add(Path.Combine(LibrariesPath, "v8_snapshot.lib"));

            PublicIncludePaths.Add(Path.Combine(ThirdPartyPath, "v8", "Includes"));

            Definitions.Add(string.Format("WITH_FLATHEAD=1"));

            return true;
        }

        Definitions.Add(string.Format("WITH_FLATHEAD=0"));
        return false;
    }
Ejemplo n.º 20
0
    public Godzilla(TargetInfo Target)
    {
        PublicDependencyModuleNames.AddRange(new string[] { "Core", "CoreUObject", "Engine", "InputCore" });

        LoadVRPN(Target);
        LoadQuat(Target);
    }
	public DesktopWidgets(TargetInfo Target)
	{
		PublicDependencyModuleNames.AddRange(
			new string[] {
				"Core",
				"Slate",
				"SlateCore",
			}
		);

		PrivateDependencyModuleNames.AddRange(
			new string[] {
                "DesktopPlatform",
                "InputCore",
			}
		);

		PrivateIncludePaths.AddRange(
			new string[] {
				"Developer/DesktopWidgets/Private",
				"Developer/DesktopWidgets/Private/Widgets",
                "Developer/DesktopWidgets/Private/Widgets/Input",
			}
		);
	}
    public override void SetupGlobalEnvironment(
		TargetInfo Target,
		ref LinkEnvironmentConfiguration OutLinkEnvironmentConfiguration,
		ref CPPEnvironmentConfiguration OutCPPEnvironmentConfiguration
		)
    {
        OutCPPEnvironmentConfiguration.Definitions.Add("WITH_DATABASE_SUPPORT=1");

        UEBuildConfiguration.bCompileLeanAndMeanUE = true;

        // Don't need editor
        UEBuildConfiguration.bBuildEditor = false;

        // MinidumpDiagnostics doesn't ever compile with the engine linked in
        UEBuildConfiguration.bCompileAgainstEngine = false;

        UEBuildConfiguration.bIncludeADO = true;

        // MinidumpDiagnostics.exe has no exports, so no need to verify that a .lib and .exp file was emitted by the linker.
        OutLinkEnvironmentConfiguration.bHasExports = false;

        // Do NOT produce additional console app exe
        OutLinkEnvironmentConfiguration.bIsBuildingConsoleApplication = true;

        OutCPPEnvironmentConfiguration.Definitions.Add("MINIDUMPDIAGNOSTICS=1");
    }
Ejemplo n.º 23
0
 public override void GetModulesToPrecompile(TargetInfo Target, List<string> ModuleNames)
 {
     ModuleNames.Add("Launch");
     ModuleNames.Add("GameMenuBuilder");
     ModuleNames.Add("JsonUtilities");
     ModuleNames.Add("RuntimeAssetCache");
     ModuleNames.Add("UnrealCodeAnalyzerTests");
     if ((Target.Platform == UnrealTargetPlatform.Win32) || (Target.Platform == UnrealTargetPlatform.Win64))
     {
         ModuleNames.Add("OnlineSubsystemNull");
         ModuleNames.Add("OnlineSubsystemAmazon");
         if (UEBuildConfiguration.bCompileSteamOSS == true)
         {
             ModuleNames.Add("OnlineSubsystemSteam");
         }
         ModuleNames.Add("OnlineSubsystemFacebook");
     }
     else if (Target.Platform == UnrealTargetPlatform.Mac || Target.Platform == UnrealTargetPlatform.Linux)
     {
         ModuleNames.Add("OnlineSubsystemNull");
         if (UEBuildConfiguration.bCompileSteamOSS == true)
         {
             ModuleNames.Add("OnlineSubsystemSteam");
         }
     }
 }
        public AutomationController(TargetInfo Target)
        {
            PublicDependencyModuleNames.AddRange(
                new string[]
                {
                    "Core",
                }
            );

            PrivateDependencyModuleNames.AddRange(
                new string[]
                {
                    "AutomationMessages",
                    "CoreUObject",
                    "Networking",
                    "UnrealEdMessages",
                }
            );

            PrivateIncludePathModuleNames.AddRange(
                new string[]
                {
                    "Messaging",
                }
            );

            PrivateIncludePaths.AddRange(
                new string[]
                {
                    "Runtime/AutomationController/Private"
                }
            );
        }
Ejemplo n.º 25
0
    public SuperSearch(TargetInfo Target)
    {
        if (UEBuildConfiguration.bBuildEditor == true)
        {
            PrivateDependencyModuleNames.AddRange(
                new string[] {
					"Core",
					"CoreUObject", // @todo Mac: for some reason it's needed to link in debug on Mac
					"Engine",
	                "InputCore",
					"Json",
					"UnrealEd",
					"Slate",
					"SlateCore",
					"EditorStyle",
					"HTTP",
					"IntroTutorials"
				}
            );
        }
        else
        {
            PrivateDependencyModuleNames.AddRange(
                new string[] {
					"Core",
					"CoreUObject", // @todo Mac: for some reason it's needed to link in debug on Mac
                    "InputCore",
					"Slate",
					"SlateCore",
	                "HTTP",
                    "Json",
			    }
            );
        }
    }
    public override void SetupGlobalEnvironment(
		TargetInfo Target,
		ref LinkEnvironmentConfiguration OutLinkEnvironmentConfiguration,
		ref CPPEnvironmentConfiguration OutCPPEnvironmentConfiguration
		)
    {
        UEBuildConfiguration.bCompileNetworkProfiler = false;

        UEBuildConfiguration.bCompileLeanAndMeanUE = true;

        // Don't need editor
        UEBuildConfiguration.bBuildEditor = false;

        // CrashReportClient doesn't ever compile with the engine linked in
        UEBuildConfiguration.bCompileAgainstEngine = false;
        UEBuildConfiguration.bCompileAgainstCoreUObject = false;

        UEBuildConfiguration.bIncludeADO = (Target.Platform == UnrealTargetPlatform.Win64 || Target.Platform == UnrealTargetPlatform.Win32);

        // CrashReportClient.exe has no exports, so no need to verify that a .lib and .exp file was emitted by
        // the linker.
        OutLinkEnvironmentConfiguration.bHasExports = false;

        // Do NOT produce additional console app exe
        OutLinkEnvironmentConfiguration.bBuildAdditionalConsoleApplication = false;

        if (UnrealBuildTool.UnrealBuildTool.BuildingRocket())
        {
            // Tag it as a Rocket build
            OutCPPEnvironmentConfiguration.Definitions.Add("UE_ROCKET=1");
        }
    }
	public DesktopPlatform(TargetInfo Target)
	{
		PrivateIncludePaths.Add("Developer/DesktopPlatform/Private");

		PrivateDependencyModuleNames.AddRange(
			new string[] {
				"Core",
				"Json",
			}
		);

		if (Target.Platform == UnrealTargetPlatform.Linux)
		{
			PrivateIncludePathModuleNames.AddRange(
				new string[] {
					"SlateFileDialogs",
				}
			);

			DynamicallyLoadedModuleNames.AddRange(
				new string[] {
					"SlateFileDialogs",
				}
			);

			AddEngineThirdPartyPrivateStaticDependencies(Target, "SDL2");
			//AddEngineThirdPartyPrivateStaticDependencies(Target, "LinuxNativeDialogs");
		}
	}
    public MaterialShaderQualitySettings(TargetInfo Target)
	{
		PrivateDependencyModuleNames.AddRange(
			new string[]
			{
				"Core",
				"CoreUObject",
                "RHI",
			}
		);
        PrivateIncludePathModuleNames.Add("Engine");

        if (UEBuildConfiguration.bBuildEditor == true)
		{
            PrivateDependencyModuleNames.AddRange(
                new string[] {            
       				"Slate",
				    "SlateCore",
				    "EditorStyle",
                    "PropertyEditor",
                    "TargetPlatform",
                    "InputCore",
                }
            );

		}

	}
Ejemplo n.º 29
0
	public Cascade(TargetInfo Target)
	{
		PublicIncludePaths.AddRange(
			new string[] {
				"Editor/DistCurveEditor/Public",
				"Editor/UnrealEd/Public",
			}
		);

		PrivateDependencyModuleNames.AddRange(
			new string[] {
                "AppFramework",
				"Core",
				"CoreUObject",
                "InputCore",
				"Engine",
				"Slate",
				"SlateCore",
                "EditorStyle",
				"DistCurveEditor",
				"UnrealEd",
				"RHI"
			}
		);

		DynamicallyLoadedModuleNames.AddRange(
			new string[] {
				"MainFrame",
				"PropertyEditor"
			}
		);
	}
Ejemplo n.º 30
0
    public MeshPaint(TargetInfo Target)
    {
        PrivateIncludePathModuleNames.Add("AssetTools");

        PrivateDependencyModuleNames.AddRange(
            new string[] {
                "AppFramework",
                "Core",
                "CoreUObject",
                "DesktopPlatform",
                "Engine",
                "InputCore",
                "RenderCore",
                "RHI",
                "ShaderCore",
                "Slate",
                "SlateCore",
                "EditorStyle",
                "UnrealEd",
                "RawMesh",
                "SourceControl"
            }
        );

        DynamicallyLoadedModuleNames.Add("AssetTools");
    }
    public NamedPipesUE4EditorTarget(TargetInfo Target) : base(Target)
    {
        Type = TargetType.Editor;

        ExtraModuleNames.AddRange(new string[] { "NamedPipesUE4" });
    }
Ejemplo n.º 32
0
 public MinecraftEditorTarget(TargetInfo Target)
 {
     Type = TargetType.Editor;
 }
Ejemplo n.º 33
0
 public ToasterMadnessEditorTarget(TargetInfo Target)
 {
     Type = TargetType.Editor;
 }
Ejemplo n.º 34
0
        public DependencyContext Build()
        {
            bool includeCompilationLibraries = _compilationOptions != null;

            IEnumerable <LockFileTargetLibrary> runtimeExports     = _projectContext.GetRuntimeLibraries(_excludeFromPublishPackageIds);
            IEnumerable <LockFileTargetLibrary> compilationExports =
                includeCompilationLibraries ?
                _projectContext.GetCompileLibraries(_excludeFromPublishPackageIds) :
                Enumerable.Empty <LockFileTargetLibrary>();

            var dependencyLookup = compilationExports
                                   .Concat(runtimeExports)
                                   .Distinct()
                                   .Select(library => new Dependency(library.Name, library.Version.ToString()))
                                   .ToDictionary(dependency => dependency.Name, StringComparer.OrdinalIgnoreCase);

            var libraryLookup = new LockFileLookup(_projectContext.LockFile);

            var runtimeSignature = string.Empty;

            IEnumerable <RuntimeLibrary> runtimeLibraries = Enumerable.Empty <RuntimeLibrary>();

            if (_includeMainProjectInDepsFile)
            {
                runtimeLibraries = runtimeLibraries.Concat(new[]
                {
                    GetProjectRuntimeLibrary(
                        _mainProjectInfo,
                        _projectContext,
                        dependencyLookup,
                        includeCompilationLibraries)
                });
            }
            runtimeLibraries = runtimeLibraries
                               .Concat(GetRuntimePackLibraries(_runtimePackAssets))
                               .Concat(GetLibraries(runtimeExports, libraryLookup, dependencyLookup, runtime: true).Cast <RuntimeLibrary>())
                               .Concat(GetDirectReferenceRuntimeLibraries())
                               .Concat(GetDependencyReferenceRuntimeLibraries());

            IEnumerable <CompilationLibrary> compilationLibraries = Enumerable.Empty <CompilationLibrary>();

            if (includeCompilationLibraries)
            {
                if (_includeMainProjectInDepsFile)
                {
                    compilationLibraries = compilationLibraries.Concat(new[]
                    {
                        GetProjectCompilationLibrary(
                            _mainProjectInfo,
                            _projectContext,
                            dependencyLookup,
                            includeCompilationLibraries)
                    });
                }

                compilationLibraries = compilationLibraries
                                       .Concat(GetReferenceAssemblyLibraries())
                                       .Concat(GetLibraries(compilationExports, libraryLookup, dependencyLookup, runtime: false).Cast <CompilationLibrary>())
                                       .Concat(GetDirectReferenceCompilationLibraries());
            }

            var targetInfo = new TargetInfo(
                _projectContext.LockFileTarget.TargetFramework.DotNetFrameworkName,
                _projectContext.LockFileTarget.RuntimeIdentifier,
                runtimeSignature,
                _projectContext.IsPortable);

            return(new DependencyContext(
                       targetInfo,
                       _compilationOptions ?? CompilationOptions.Default,
                       compilationLibraries,
                       runtimeLibraries,
                       new RuntimeFallbacks[] { }));
        }
Ejemplo n.º 35
0
    public Chapter_11EditorTarget(TargetInfo Target) : base(Target)
    {
        Type = TargetType.Editor;

        ExtraModuleNames.AddRange(new string[] { "Chapter_11" });
    }
Ejemplo n.º 36
0
 public PixelateTarget(TargetInfo Target) : base(Target)
 {
     Type = TargetType.Game;
     ExtraModuleNames.Add("Pixelate");
 }
Ejemplo n.º 37
0
    public LevelEditor(TargetInfo Target)
    {
        PrivateIncludePathModuleNames.AddRange(
            new string[] {
            "AssetTools",
            "ClassViewer",
            "MainFrame",
            "PlacementMode",
            "ReferenceViewer",
            "SizeMap",
            "IntroTutorials",
            "AppFramework"
        }
            );

        PublicIncludePathModuleNames.AddRange(
            new string[] {
            "Settings",
            "UserFeedback",
            "IntroTutorials"
        }
            );

        PrivateDependencyModuleNames.AddRange(
            new string[] {
            "Analytics",
            "Core",
            "CoreUObject",
            "DesktopPlatform",
            "InputCore",
            "Slate",
            "SlateCore",
            "SlateReflector",
            "EditorStyle",
            "Engine",
            "MessageLog",
            "NewsFeed",
            "SourceControl",
            "SourceControlWindows",
            "StatsViewer",
            "UnrealEd",
            "RenderCore",
            "DeviceProfileServices",
            "ContentBrowser",
            "SceneOutliner",
            "ActorPickerMode",
            "RHI",
            "Projects",
            "TargetPlatform",
            "EngineSettings",
            "PropertyEditor",
            "WebBrowser",
            "Persona",
            "Kismet",
            "KismetWidgets"
        }
            );

        DynamicallyLoadedModuleNames.AddRange(
            new string[] {
            "MainFrame",
            "PropertyEditor",
            "SceneOutliner",
            "ClassViewer",
            "DeviceManager",
            "SettingsEditor",
            "SessionFrontend",
            "AutomationWindow",
            "Layers",
            "WorldBrowser",
            "EditorWidgets",
            "AssetTools",
            "WorkspaceMenuStructure",
            "NewLevelDialog",
            "DeviceProfileEditor",
            "DeviceProfileServices",
            "PlacementMode",
            "UserFeedback",
            "ReferenceViewer",
            "SizeMap",
            "IntroTutorials"
        }
            );
    }
Ejemplo n.º 38
0
 public HackMWTarget(TargetInfo Target)
 {
     Type = TargetType.Game;
 }
    public C_EscapeRoomEditorTarget(TargetInfo Target) : base(Target)
    {
        Type = TargetType.Editor;

        ExtraModuleNames.AddRange(new string[] { "C_EscapeRoom" });
    }
Ejemplo n.º 40
0
 public TP_TopDown(TargetInfo Target)
 {
     PublicDependencyModuleNames.AddRange(new string[] { "Core", "CoreUObject", "Engine", "InputCore" });
 }
Ejemplo n.º 41
0
 public GDKTestGymsEditorTarget(TargetInfo Target) : base(Target)
 {
     Type = TargetType.Editor;
     ExtraModuleNames.Add("GDKTestGyms");
 }
Ejemplo n.º 42
0
    public CDLODTarget(TargetInfo Target) : base(Target)
    {
        Type = TargetType.Game;

        ExtraModuleNames.AddRange(new string[] { "CDLOD" });
    }
Ejemplo n.º 43
0
 public Species_cppEditorTarget(TargetInfo Target) : base(Target)
 {
     Type = TargetType.Editor;
     ExtraModuleNames.Add("Species_cpp");
 }
Ejemplo n.º 44
0
 public Noah(TargetInfo Target)
 {
     PublicDependencyModuleNames.AddRange(new string[] { "Core", "CoreUObject", "Engine", "InputCore", "HeadMountedDisplay" });
 }
Ejemplo n.º 45
0
    public GladiatorArenaEditorTarget(TargetInfo Target) : base(Target)
    {
        Type = TargetType.Editor;

        ExtraModuleNames.AddRange(new string[] { "GladiatorArena" });
    }
Ejemplo n.º 46
0
    public PgrEditorTarget(TargetInfo Target) : base(Target)
    {
        Type = TargetType.Editor;

        ExtraModuleNames.AddRange(new string[] { "Pgr" });
    }
Ejemplo n.º 47
0
    public TutorialSandboxEditorTarget(TargetInfo Target) : base(Target)
    {
        Type = TargetType.Editor;

        ExtraModuleNames.AddRange(new string[] { "TutorialSandbox" });
    }
    public Mega_lo_ManiaTarget(TargetInfo Target) : base(Target)
    {
        Type = TargetType.Game;

        ExtraModuleNames.AddRange(new string[] { "Mega_lo_Mania" });
    }
Ejemplo n.º 49
0
 public VRTestingEditorTarget(TargetInfo Target)
 {
     Type = TargetType.Editor;
 }
Ejemplo n.º 50
0
    public BattleTanksTarget(TargetInfo Target) : base(Target)
    {
        Type = TargetType.Game;

        ExtraModuleNames.AddRange(new string[] { "BattleTanks" });
    }
Ejemplo n.º 51
0
 public TestCrawlerTarget(TargetInfo Target) : base(Target)
 {
     Type = TargetType.Game;
     DefaultBuildSettings = BuildSettingsVersion.V2;
     ExtraModuleNames.Add("TestCrawler");
 }
    public MaterialAndShadingTarget(TargetInfo Target) : base(Target)
    {
        Type = TargetType.Game;

        ExtraModuleNames.AddRange(new string[] { "MaterialAndShading" });
    }
    public ShaderPluginDemoTarget(TargetInfo Target) : base(Target)
    {
        Type = TargetType.Game;

        ExtraModuleNames.AddRange(new string[] { "ShaderPluginDemo" });
    }
 public CodingProjectEditorTarget(TargetInfo Target) : base(Target)
 {
     Type = TargetType.Editor;
     DefaultBuildSettings = BuildSettingsVersion.V2;
     ExtraModuleNames.AddRange(new string[] { "CodingProject" });
 }
    public UnrealLightmass(TargetInfo Target)
    {
        PublicIncludePaths.Add("Runtime/Launch/Public");

        PrivateDependencyModuleNames.AddRange(new string[] { "Core", "CoreUObject", "zlib", "SwarmInterface", "Projects" });

        Definitions.Add("UE_LIGHTMASS=1");

        if ((Target.Platform == UnrealTargetPlatform.Win64) || (Target.Platform == UnrealTargetPlatform.Win32))
        {
            AddEngineThirdPartyPrivateStaticDependencies(Target, "DX9");

            // Unreallightmass requires GetProcessMemoryInfo exported by psapi.dll. http://msdn.microsoft.com/en-us/library/windows/desktop/ms683219(v=vs.85).aspx
            PublicAdditionalLibraries.Add("psapi.lib");
            PrivateDependencyModuleNames.AddRange(
                new string[] {
                "Messaging",
            }
                );
        }
        else if (Target.Platform == UnrealTargetPlatform.Mac || Target.Platform == UnrealTargetPlatform.Linux)
        {
            // On Mac/Linux UnrealLightmass is executed locally and communicates with the editor using Messaging module instead of SwarmAgent
            // @todo: allow for better plug-in support in standalone Slate apps
            PrivateDependencyModuleNames.AddRange(
                new string[] {
                "Networking",
                "Sockets",
                "Messaging",
                "UdpMessaging",
            }
                );

            PrivateIncludePathModuleNames.AddRange(
                new string[] {
                "Messaging",
            }
                );
        }

        // Lightmass ray tracing is 8% faster with buffer security checks disabled due to fixed size arrays on the stack in the kDOP ray tracing functions
        // Warning: This means buffer overwrites will not be detected
        bEnableBufferSecurityChecks = false;

        PrivateIncludePaths.Add("Runtime/Launch/Private");                      // For LaunchEngineLoop.cpp include
        PrivateIncludePaths.Add("Programs/UnrealLightmass/Private/Launch");
        PrivateIncludePaths.Add("Programs/UnrealLightmass/Private/ImportExport");
        PrivateIncludePaths.Add("Programs/UnrealLightmass/Private/CPUSolver");
        PrivateIncludePaths.Add("Programs/UnrealLightmass/Private/Lighting");
        PrivateIncludePaths.Add("Programs/UnrealLightmass/Private/LightmassCore");
        PrivateIncludePaths.Add("Programs/UnrealLightmass/Private/LightmassCore/Misc");
        PrivateIncludePaths.Add("Programs/UnrealLightmass/Private/LightmassCore/Math");
        PrivateIncludePaths.Add("Programs/UnrealLightmass/Private/LightmassCore/Templates");
        PrivateIncludePaths.Add("Programs/UnrealLightmass/Private/LightmassCore/Types");

        // EMBREE
        if (Target.Platform == UnrealTargetPlatform.Win64)
        {
            string SDKDir = UEBuildConfiguration.UEThirdPartySourceDirectory + "IntelEmbree/Embree270/Win64/";

            PublicIncludePaths.Add(SDKDir + "include");
            PublicLibraryPaths.Add(SDKDir + "lib");
            PublicAdditionalLibraries.Add("embree.lib");
            RuntimeDependencies.Add(new RuntimeDependency("$(EngineDir)/Binaries/Win64/embree.dll"));
            RuntimeDependencies.Add(new RuntimeDependency("$(EngineDir)/Binaries/Win64/tbb.dll"));
            RuntimeDependencies.Add(new RuntimeDependency("$(EngineDir)/Binaries/Win64/tbbmalloc.dll"));
            Definitions.Add("USE_EMBREE=1");
        }
        else if (Target.Platform == UnrealTargetPlatform.Mac)
        {
            string SDKDir = UEBuildConfiguration.UEThirdPartySourceDirectory + "IntelEmbree/Embree270/MacOSX/";

            PublicIncludePaths.Add(SDKDir + "include");
            PublicAdditionalLibraries.Add(SDKDir + "lib/libembree.2.dylib");
            RuntimeDependencies.Add(new RuntimeDependency("$(EngineDir)/Binaries/Mac/libembree.2.dylib"));
            RuntimeDependencies.Add(new RuntimeDependency("$(EngineDir)/Binaries/Mac/libtbb.dylib"));
            RuntimeDependencies.Add(new RuntimeDependency("$(EngineDir)/Binaries/Mac/libtbbmalloc.dylib"));
            Definitions.Add("USE_EMBREE=1");
        }
        else
        {
            Definitions.Add("USE_EMBREE=0");
        }
    }