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",
			    }
            );
        }
    }

        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"
            }
        );
    }

    public Godzilla(TargetInfo Target)
    {
        PublicDependencyModuleNames.AddRange(new string[] { "Core", "CoreUObject", "Engine", "InputCore" });

        LoadVRPN(Target);
        LoadQuat(Target);
    }