Inheritance: MonoBehaviour
	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"
			}
		);
	}
    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 SceneOutliner(TargetInfo Target)
	{
		PrivateIncludePathModuleNames.AddRange(
			new string[] {
			}
		);

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

		PrivateIncludePathModuleNames.AddRange(
			new string[] {
				"LevelEditor"
			}
		);
	}
	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"
			}
		);
	}
    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);
        }
    }
        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",
				}
				);
		}
        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 ...
				}
				);
		}
        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"
                }
            );
        }
	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
		)
    {
        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 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 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",
    }
         );
     }
 }
Example #13
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 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 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 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");
    }
	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 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 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"
            }
        );
    }
Example #20
0
    public Godzilla(TargetInfo Target)
    {
        PublicDependencyModuleNames.AddRange(new string[] { "Core", "CoreUObject", "Engine", "InputCore" });

        LoadVRPN(Target);
        LoadQuat(Target);
    }
    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 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 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");
        }
    }
		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"
				}
				);
		}
        public CodeView(TargetInfo Target)
        {
            PublicDependencyModuleNames.AddRange(
                new string[]
                {
                    "Slate",
                    "InputCore",
                    "Core",
                    "CoreUObject",
                    "Engine",
                    "UnrealEd",
                    "EditorStyle",
                    "PropertyEditor",
                    "DesktopPlatform",
                }
            );

            PrivateDependencyModuleNames.AddRange(
                new string[]
                {
                    "DetailCustomizations",
                    "SlateCore",
                }
            );
        }
Example #26
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;
    }
	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"
			}
		);
	}
	public override void SetupGlobalEnvironment(
		TargetInfo Target,
		ref LinkEnvironmentConfiguration OutLinkEnvironmentConfiguration,
		ref CPPEnvironmentConfiguration OutCPPEnvironmentConfiguration
		)
	{
	}
    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 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",
                }
            );

		}

	}