Exemple #1
0
 /**
  *	Modify the newly created module passed in for this platform.
  *	This is not required - but allows for hiding details of a
  *	particular platform.
  *
  *	@param	InModule		The newly loaded module
  *	@param	Target			The target being build
  */
 public override void ModifyNewlyLoadedModule(UEBuildModule InModule, TargetInfo Target)
 {
     if (Target.Platform == UnrealTargetPlatform.HTML5)
     {
         if (InModule.ToString() == "Core")
         {
             InModule.AddPublicIncludePath("Runtime/Core/Public/HTML5");
             InModule.AddPublicDependencyModule("zlib");
         }
         else if (InModule.ToString() == "Engine")
         {
             InModule.AddPrivateDependencyModule("zlib");
             InModule.AddPrivateDependencyModule("UElibPNG");
             InModule.AddPublicDependencyModule("UEOgg");
             InModule.AddPublicDependencyModule("Vorbis");
         }
     }
     else if (Target.Platform == UnrealTargetPlatform.Win32 || Target.Platform == UnrealTargetPlatform.Win64 || Target.Platform == UnrealTargetPlatform.Mac)
     {
         // allow standalone tools to use targetplatform modules, without needing Engine
         if ((!UEBuildConfiguration.bBuildRequiresCookedData &&
              InModule.ToString() == "Engine" &&
              UEBuildConfiguration.bBuildDeveloperTools) ||
             UEBuildConfiguration.bForceBuildTargetPlatforms)
         {
             InModule.AddPlatformSpecificDynamicallyLoadedModule("HTML5TargetPlatform");
         }
     }
 }
Exemple #2
0
        public override void ModifyNewlyLoadedModule(UEBuildModule InModule, TargetInfo Target)
        {
            if ((Target.Platform == UnrealTargetPlatform.Win32) || (Target.Platform == UnrealTargetPlatform.Win64))
            {
                bool bBuildShaderFormats = UEBuildConfiguration.bForceBuildShaderFormats;
                if (!UEBuildConfiguration.bBuildRequiresCookedData)
                {
                    if (InModule.ToString() == "Engine")
                    {
                        if (UEBuildConfiguration.bBuildDeveloperTools)
                        {
                            InModule.AddPlatformSpecificDynamicallyLoadedModule("AndroidTargetPlatform");
                            InModule.AddPlatformSpecificDynamicallyLoadedModule("Android_PVRTCTargetPlatform");
                            InModule.AddPlatformSpecificDynamicallyLoadedModule("Android_ATCTargetPlatform");
                            InModule.AddPlatformSpecificDynamicallyLoadedModule("Android_DXTTargetPlatform");
                            InModule.AddPlatformSpecificDynamicallyLoadedModule("Android_ETC1TargetPlatform");
                            InModule.AddPlatformSpecificDynamicallyLoadedModule("Android_ETC2TargetPlatform");
//                            InModule.AddPlatformSpecificDynamicallyLoadedModule("Android_GL4TargetPlatform");
                            // @todo es31: Put this back in for ES31 support
                            // ES31 code is in, but it's not fully supported in UE4 4.5, so for now we need to disable the targetplatform as it will confuse people greatly
                            // InModule.AddPlatformSpecificDynamicallyLoadedModule("Android_ES31TargetPlatform");
                        }
                    }
                    else if (InModule.ToString() == "TargetPlatform")
                    {
                        bBuildShaderFormats = true;
                        InModule.AddDynamicallyLoadedModule("TextureFormatPVR");
                        InModule.AddDynamicallyLoadedModule("TextureFormatDXT");
                        InModule.AddPlatformSpecificDynamicallyLoadedModule("TextureFormatAndroid");    // ATITC, ETC1 and ETC2
                        if (UEBuildConfiguration.bBuildDeveloperTools)
                        {
                            //InModule.AddDynamicallyLoadedModule("AudioFormatADPCM");	//@todo android: android audio
                        }
                    }
                }

                // allow standalone tools to use targetplatform modules, without needing Engine
                if (UEBuildConfiguration.bForceBuildTargetPlatforms)
                {
                    InModule.AddPlatformSpecificDynamicallyLoadedModule("AndroidTargetPlatform");
                    InModule.AddPlatformSpecificDynamicallyLoadedModule("Android_PVRTCTargetPlatform");
                    InModule.AddPlatformSpecificDynamicallyLoadedModule("Android_ATCTargetPlatform");
                    InModule.AddPlatformSpecificDynamicallyLoadedModule("Android_DXTTargetPlatform");
                    InModule.AddPlatformSpecificDynamicallyLoadedModule("Android_ETC1TargetPlatform");
                    InModule.AddPlatformSpecificDynamicallyLoadedModule("Android_ETC2TargetPlatform");
//                    InModule.AddPlatformSpecificDynamicallyLoadedModule("Android_GL4TargetPlatform");
                    // @todo es31: Put this back in for ES31 support
                    // ES31 code is in, but it's not fully supported in UE4 4.5, so for now we need to disable the targetplatform as it will confuse people greatly
                    // InModule.AddPlatformSpecificDynamicallyLoadedModule("Android_ES31TargetPlatform");
                }

                if (bBuildShaderFormats)
                {
                    //InModule.AddDynamicallyLoadedModule("ShaderFormatAndroid");		//@todo android: ShaderFormatAndroid
                }
            }
        }
        public override void ModifyNewlyLoadedModule(UEBuildModule InModule, TargetInfo Target)
        {
            if ((Target.Platform == UnrealTargetPlatform.Win32) || (Target.Platform == UnrealTargetPlatform.Win64) || (Target.Platform == UnrealTargetPlatform.Mac))
            {
                bool bBuildShaderFormats = UEBuildConfiguration.bForceBuildShaderFormats;
                if (!UEBuildConfiguration.bBuildRequiresCookedData)
                {
                    if (InModule.ToString() == "Engine")
                    {
                        if (UEBuildConfiguration.bBuildDeveloperTools)
                        {
                            InModule.AddPlatformSpecificDynamicallyLoadedModule("AndroidTargetPlatform");
                            InModule.AddPlatformSpecificDynamicallyLoadedModule("Android_PVRTCTargetPlatform");
                            InModule.AddPlatformSpecificDynamicallyLoadedModule("Android_ATCTargetPlatform");
                            InModule.AddPlatformSpecificDynamicallyLoadedModule("Android_DXTTargetPlatform");
                            InModule.AddPlatformSpecificDynamicallyLoadedModule("Android_ETC1TargetPlatform");
                            InModule.AddPlatformSpecificDynamicallyLoadedModule("Android_ETC2TargetPlatform");
                            InModule.AddPlatformSpecificDynamicallyLoadedModule("Android_ES31TargetPlatform");
                            // @todo gl4android
                            // InModule.AddPlatformSpecificDynamicallyLoadedModule("Android_GL4TargetPlatform");
                        }
                    }
                    else if (InModule.ToString() == "TargetPlatform")
                    {
                        bBuildShaderFormats = true;
                        InModule.AddDynamicallyLoadedModule("TextureFormatPVR");
                        InModule.AddDynamicallyLoadedModule("TextureFormatDXT");
                        InModule.AddDynamicallyLoadedModule("TextureFormatASTC");
                        InModule.AddPlatformSpecificDynamicallyLoadedModule("TextureFormatAndroid");                            // ATITC, ETC1 and ETC2
                        if (UEBuildConfiguration.bBuildDeveloperTools)
                        {
                            //InModule.AddDynamicallyLoadedModule("AudioFormatADPCM");	//@todo android: android audio
                        }
                    }
                }

                // allow standalone tools to use targetplatform modules, without needing Engine
                if (UEBuildConfiguration.bForceBuildTargetPlatforms)
                {
                    InModule.AddPlatformSpecificDynamicallyLoadedModule("AndroidTargetPlatform");
                    InModule.AddPlatformSpecificDynamicallyLoadedModule("Android_PVRTCTargetPlatform");
                    InModule.AddPlatformSpecificDynamicallyLoadedModule("Android_ATCTargetPlatform");
                    InModule.AddPlatformSpecificDynamicallyLoadedModule("Android_DXTTargetPlatform");
                    InModule.AddPlatformSpecificDynamicallyLoadedModule("Android_ETC1TargetPlatform");
                    InModule.AddPlatformSpecificDynamicallyLoadedModule("Android_ETC2TargetPlatform");
                    InModule.AddPlatformSpecificDynamicallyLoadedModule("Android_ES31TargetPlatform");
                    // @todo gl4android
                    // InModule.AddPlatformSpecificDynamicallyLoadedModule("Android_GL4TargetPlatform");
                }

                if (bBuildShaderFormats)
                {
                    //InModule.AddDynamicallyLoadedModule("ShaderFormatAndroid");		//@todo android: ShaderFormatAndroid
                }
            }
        }
        /**
         *	Modify the newly created module passed in for this platform.
         *	This is not required - but allows for hiding details of a
         *	particular platform.
         *
         *	@param	InModule		The newly loaded module
         *	@param	Target			The target being build
         */
        public override void ModifyNewlyLoadedModule(UEBuildModule InModule, TargetInfo Target)
        {
            if ((Target.Platform == UnrealTargetPlatform.Win32) || (Target.Platform == UnrealTargetPlatform.Win64))
            {
                if (!UEBuildConfiguration.bBuildRequiresCookedData)
                {
                    if (InModule.ToString() == "Engine")
                    {
                        if (UEBuildConfiguration.bBuildDeveloperTools)
                        {
                            InModule.AddPlatformSpecificDynamicallyLoadedModule("LinuxTargetPlatform");
                            InModule.AddPlatformSpecificDynamicallyLoadedModule("LinuxNoEditorTargetPlatform");
                            InModule.AddPlatformSpecificDynamicallyLoadedModule("LinuxServerTargetPlatform");
                        }
                    }
                }

                // allow standalone tools to use targetplatform modules, without needing Engine
                if (UEBuildConfiguration.bForceBuildTargetPlatforms)
                {
                    InModule.AddPlatformSpecificDynamicallyLoadedModule("LinuxTargetPlatform");
                    InModule.AddPlatformSpecificDynamicallyLoadedModule("LinuxNoEditorTargetPlatform");
                    InModule.AddPlatformSpecificDynamicallyLoadedModule("LinuxServerTargetPlatform");
                }
            }
            else if (Target.Platform == UnrealTargetPlatform.Linux)
            {
                bool bBuildShaderFormats = UEBuildConfiguration.bForceBuildShaderFormats;

                if (!UEBuildConfiguration.bBuildRequiresCookedData)
                {
                    if (InModule.ToString() == "TargetPlatform")
                    {
                        bBuildShaderFormats = true;
                    }
                }

                // allow standalone tools to use target platform modules, without needing Engine
                if (UEBuildConfiguration.bForceBuildTargetPlatforms)
                {
                    InModule.AddDynamicallyLoadedModule("LinuxTargetPlatform");
                    InModule.AddDynamicallyLoadedModule("LinuxNoEditorTargetPlatform");
                    InModule.AddDynamicallyLoadedModule("LinuxServerTargetPlatform");
                    InModule.AddDynamicallyLoadedModule("AllDesktopTargetPlatform");
                }

                if (bBuildShaderFormats)
                {
                    // InModule.AddDynamicallyLoadedModule("ShaderFormatD3D");
                    InModule.AddDynamicallyLoadedModule("ShaderFormatOpenGL");
                }
            }
        }
        public override void ModifyNewlyLoadedModule(UEBuildModule InModule, TargetInfo Target)
        {
            if ((Target.Platform == UnrealTargetPlatform.Win32) || (Target.Platform == UnrealTargetPlatform.Win64))
            {
                bool bBuildShaderFormats = UEBuildConfiguration.bForceBuildShaderFormats;

                if (!UEBuildConfiguration.bBuildRequiresCookedData)
                {
                    if (InModule.ToString() == "TargetPlatform")
                    {
                        bBuildShaderFormats = true;
                    }
                }

                // allow standalone tools to use target platform modules, without needing Engine
                if (UEBuildConfiguration.bForceBuildTargetPlatforms)
                {
                    InModule.AddDynamicallyLoadedModule("WindowsTargetPlatform");
                    InModule.AddDynamicallyLoadedModule("WindowsNoEditorTargetPlatform");
                    InModule.AddDynamicallyLoadedModule("WindowsServerTargetPlatform");
                    InModule.AddDynamicallyLoadedModule("WindowsClientTargetPlatform");
                    InModule.AddDynamicallyLoadedModule("AllDesktopTargetPlatform");
                }

                if (bBuildShaderFormats)
                {
                    InModule.AddDynamicallyLoadedModule("ShaderFormatD3D");
                    InModule.AddDynamicallyLoadedModule("ShaderFormatOpenGL");

//#todo-rco: Remove when public
                    {
                        string VulkanSDKPath = Environment.GetEnvironmentVariable("VulkanSDK");
                        if (!String.IsNullOrEmpty(VulkanSDKPath))
                        {
                            InModule.AddDynamicallyLoadedModule("VulkanShaderFormat");
                        }
                    }
                }

                if (InModule.ToString() == "D3D11RHI")
                {
                    // To enable platform specific D3D11 RHI Types
                    InModule.AddPrivateIncludePath("Runtime/Windows/D3D11RHI/Private/Windows");
                }

                if (InModule.ToString() == "D3D12RHI")
                {
                    // To enable platform specific D3D12 RHI Types
                    InModule.AddPrivateIncludePath("Runtime/Windows/D3D12RHI/Private/Windows");
                }
            }
        }
Exemple #6
0
        public override void ModifyNewlyLoadedModule(UEBuildModule InModule, TargetInfo Target)
        {
            if (Target.Platform == UnrealTargetPlatform.Mac)
            {
                bool bBuildShaderFormats = UEBuildConfiguration.bForceBuildShaderFormats;

                if (!UEBuildConfiguration.bBuildRequiresCookedData)
                {
                    if (InModule.ToString() == "TargetPlatform")
                    {
                        bBuildShaderFormats = true;
                    }
                }

                // allow standalone tools to use target platform modules, without needing Engine
                if (UEBuildConfiguration.bForceBuildTargetPlatforms)
                {
                    InModule.AddDynamicallyLoadedModule("MacTargetPlatform");
                    InModule.AddDynamicallyLoadedModule("MacNoEditorTargetPlatform");
                    InModule.AddDynamicallyLoadedModule("MacClientTargetPlatform");
                    InModule.AddDynamicallyLoadedModule("MacServerTargetPlatform");
                }

                if (bBuildShaderFormats)
                {
                    InModule.AddDynamicallyLoadedModule("ShaderFormatOpenGL");
                }
            }
        }
        /**
         *     Modify the newly created module passed in for this platform.
         *     This is not required - but allows for hiding details of a
         *     particular platform.
         *
         *     @param InModule             The newly loaded module
         *     @param GameName             The game being build
         *     @param Target               The target being build
         */
        public override void ModifyNewlyLoadedModule(UEBuildModule InModule, TargetInfo Target)
        {
            if ((Target.Platform == UnrealTargetPlatform.Win32) || (Target.Platform == UnrealTargetPlatform.Win64) || (Target.Platform == UnrealTargetPlatform.Mac))
            {
                bool bBuildShaderFormats = UEBuildConfiguration.bForceBuildShaderFormats;
                if (!UEBuildConfiguration.bBuildRequiresCookedData)
                {
                    if (InModule.ToString() == "Engine")
                    {
                        if (UEBuildConfiguration.bBuildDeveloperTools)
                        {
                            InModule.AddPlatformSpecificDynamicallyLoadedModule("IOSTargetPlatform");
                        }
                    }
                    else if (InModule.ToString() == "UnrealEd")
                    {
                        InModule.AddPlatformSpecificDynamicallyLoadedModule("IOSPlatformEditor");
                    }
                    else if (InModule.ToString() == "TargetPlatform")
                    {
                        bBuildShaderFormats = true;
                        InModule.AddDynamicallyLoadedModule("TextureFormatPVR");
                        if (UEBuildConfiguration.bBuildDeveloperTools)
                        {
                            InModule.AddPlatformSpecificDynamicallyLoadedModule("AudioFormatADPCM");
                        }
                    }
                }

                // allow standalone tools to use targetplatform modules, without needing Engine
                if (UEBuildConfiguration.bForceBuildTargetPlatforms)
                {
                    InModule.AddPlatformSpecificDynamicallyLoadedModule("IOSTargetPlatform");
                }

                if (bBuildShaderFormats)
                {
                    InModule.AddPlatformSpecificDynamicallyLoadedModule("MetalShaderFormat");
                }
            }
        }
        public override void ModifyNewlyLoadedModule(UEBuildModule InModule, TargetInfo Target)
        {
            if ((Target.Platform == UnrealTargetPlatform.Win32) || (Target.Platform == UnrealTargetPlatform.Win64))
            {
                bool bBuildShaderFormats = UEBuildConfiguration.bForceBuildShaderFormats;

                if (!UEBuildConfiguration.bBuildRequiresCookedData)
                {
                    if (InModule.ToString() == "TargetPlatform")
                    {
                        bBuildShaderFormats = true;
                    }
                }

                // allow standalone tools to use target platform modules, without needing Engine
                if (UEBuildConfiguration.bForceBuildTargetPlatforms)
                {
                    InModule.AddDynamicallyLoadedModule("WindowsTargetPlatform");
                    InModule.AddDynamicallyLoadedModule("WindowsNoEditorTargetPlatform");
                    InModule.AddDynamicallyLoadedModule("WindowsServerTargetPlatform");
                    InModule.AddDynamicallyLoadedModule("WindowsClientTargetPlatform");
                }

                if (bBuildShaderFormats)
                {
                    InModule.AddDynamicallyLoadedModule("ShaderFormatD3D");
                    InModule.AddDynamicallyLoadedModule("ShaderFormatOpenGL");
                }

                if (InModule.ToString() == "D3D11RHI")
                {
                    // To enable platform specific D3D11 RHI Types
                    InModule.AddPrivateIncludePath("Runtime/Windows/D3D11RHI/Private/Windows");
                }
            }
        }
Exemple #9
0
 public override void ModifyNewlyLoadedModule(UEBuildModule InModule, TargetInfo Target)
 {
     if ((Target.Platform == UnrealTargetPlatform.UWP))
     {
         if (InModule.ToString() == "Core")
         {
             InModule.AddPrivateDependencyModule("UWPSDK");
         }
         else if (InModule.ToString() == "Engine")
         {
             InModule.AddPrivateDependencyModule("zlib");
             InModule.AddPrivateDependencyModule("UElibPNG");
             InModule.AddPublicDependencyModule("UEOgg");
             InModule.AddPublicDependencyModule("Vorbis");
         }
         else if (InModule.ToString() == "D3D11RHI")
         {
             InModule.AddPublicDefinition("D3D11_WITH_DWMAPI=0");
             InModule.AddPublicDefinition("WITH_DX_PERF=0");
         }
         else if (InModule.ToString() == "DX11")
         {
             // Clear out all the Windows include paths and libraries...
             // The UWPSDK module handles proper paths and libs for UWP.
             // However, the D3D11RHI module will include the DX11 module.
             InModule.ClearPublicIncludePaths();
             InModule.ClearPublicLibraryPaths();
             InModule.ClearPublicAdditionalLibraries();
             InModule.RemovePublicDefinition("WITH_D3DX_LIBS=1");
             InModule.AddPublicDefinition("WITH_D3DX_LIBS=0");
             InModule.RemovePublicAdditionalLibrary("X3DAudio.lib");
             InModule.RemovePublicAdditionalLibrary("XAPOFX.lib");
         }
         else if (InModule.ToString() == "XAudio2")
         {
             InModule.AddPublicDefinition("XAUDIO_SUPPORTS_XMA2WAVEFORMATEX=0");
             InModule.AddPublicDefinition("XAUDIO_SUPPORTS_DEVICE_DETAILS=0");
             InModule.AddPublicDefinition("XAUDIO2_SUPPORTS_MUSIC=0");
             InModule.AddPublicDefinition("XAUDIO2_SUPPORTS_SENDLIST=0");
             InModule.AddPublicAdditionalLibrary("XAudio2.lib");
         }
         else if (InModule.ToString() == "DX11Audio")
         {
             InModule.RemovePublicAdditionalLibrary("X3DAudio.lib");
             InModule.RemovePublicAdditionalLibrary("XAPOFX.lib");
         }
     }
 }
Exemple #10
0
 public override void ModifyNewlyLoadedModule(UEBuildModule InModule, TargetInfo Target)
 {
     if ((Target.Platform == UnrealTargetPlatform.UWP))
     {
         if (InModule.ToString() == "Core")
         {
             InModule.AddPrivateDependencyModule("UWPSDK");
         }
         else if (InModule.ToString() == "Engine")
         {
             InModule.AddPrivateDependencyModule("zlib");
             InModule.AddPrivateDependencyModule("UElibPNG");
             InModule.AddPublicDependencyModule("UEOgg");
             InModule.AddPublicDependencyModule("Vorbis");
         }
         else if (InModule.ToString() == "D3D11RHI")
         {
             InModule.AddPublicDefinition("D3D11_WITH_DWMAPI=0");
             InModule.AddPublicDefinition("WITH_DX_PERF=0");
         }
         else if (InModule.ToString() == "DX11")
         {
             // Clear out all the Windows include paths and libraries...
             // The UWPSDK module handles proper paths and libs for UWP.
             // However, the D3D11RHI module will include the DX11 module.
             InModule.ClearPublicIncludePaths();
             InModule.ClearPublicLibraryPaths();
             InModule.ClearPublicAdditionalLibraries();
             InModule.RemovePublicDefinition("WITH_D3DX_LIBS=1");
             InModule.AddPublicDefinition("WITH_D3DX_LIBS=0");
             InModule.RemovePublicAdditionalLibrary("X3DAudio.lib");
             InModule.RemovePublicAdditionalLibrary("XAPOFX.lib");
         }
         else if (InModule.ToString() == "XAudio2")
         {
             InModule.AddPublicDefinition("XAUDIO_SUPPORTS_XMA2WAVEFORMATEX=0");
             InModule.AddPublicDefinition("XAUDIO_SUPPORTS_DEVICE_DETAILS=0");
             InModule.AddPublicDefinition("XAUDIO2_SUPPORTS_MUSIC=0");
             InModule.AddPublicDefinition("XAUDIO2_SUPPORTS_SENDLIST=0");
             InModule.AddPublicAdditionalLibrary("XAudio2.lib");
         }
         else if (InModule.ToString() == "DX11Audio")
         {
             InModule.RemovePublicAdditionalLibrary("X3DAudio.lib");
             InModule.RemovePublicAdditionalLibrary("XAPOFX.lib");
         }
     }
 }
        /**
         *	Modify the newly created module passed in for this platform.
         *	This is not required - but allows for hiding details of a
         *	particular platform.
         *
         *	@param	InModule		The newly loaded module
         *	@param	Target			The target being build
         */
        public override void ModifyNewlyLoadedModule(UEBuildModule InModule, TargetInfo Target)
        {
            if (Target.Platform == UnrealTargetPlatform.HTML5)
            {
                if (InModule.ToString() == "Core")
                {
                    InModule.AddPublicIncludePath("Runtime/Core/Public/HTML5");
                    InModule.AddPublicDependencyModule("zlib");
                }
                else if (InModule.ToString() == "Engine")
                {
                    InModule.AddPrivateDependencyModule("zlib");
                    InModule.AddPrivateDependencyModule("UElibPNG");
                    InModule.AddPublicDependencyModule("UEOgg");
                    InModule.AddPublicDependencyModule("Vorbis");
                }
            }
            else if (Target.Platform == UnrealTargetPlatform.Win64)
            {
                bool bBuildShaderFormats = UEBuildConfiguration.bForceBuildShaderFormats;
                if (!UEBuildConfiguration.bBuildRequiresCookedData)
                {
                    if (InModule.ToString() == "Engine")
                    {
                        if (UEBuildConfiguration.bBuildDeveloperTools)
                        {
                            InModule.AddPlatformSpecificDynamicallyLoadedModule("HTML5TargetPlatform");
                        }
                    }
                    else if (InModule.ToString() == "TargetPlatform")
                    {
                        bBuildShaderFormats = true;
            // 							if (UEBuildConfiguration.bBuildDeveloperTools)
            // 							{
                        // 								InModule.AddPlatformSpecificDynamicallyLoadedModule("AT9AudioFormat");
                        // 								InModule.AddPlatformSpecificDynamicallyLoadedModule("HTML5TextureFormat");
            // 							}
                    }
                }

                // allow standalone tools to use target platform modules, without needing Engine
                if (UEBuildConfiguration.bForceBuildTargetPlatforms)
                {
                    InModule.AddPlatformSpecificDynamicallyLoadedModule("HTML5TargetPlatform");
                }

                if (bBuildShaderFormats)
                {
                    // InModule.AddDynamicallyLoadedModule("HTML5ShaderFormat");
                }
            }
        }
Exemple #12
0
        /**
         *	Modify the newly created module passed in for this platform.
         *	This is not required - but allows for hiding details of a
         *	particular platform.
         *
         *	@param	InModule		The newly loaded module
         *	@param	Target			The target being build
         */
        public override void ModifyNewlyLoadedModule(UEBuildModule InModule, TargetInfo Target)
        {
            if (Target.Platform == UnrealTargetPlatform.HTML5)
            {
                if (InModule.ToString() == "Core")
                {
                    InModule.AddPublicIncludePath("Runtime/Core/Public/HTML5");
                    InModule.AddPublicDependencyModule("zlib");
                }
                else if (InModule.ToString() == "Engine")
                {
                    InModule.AddPrivateDependencyModule("zlib");
                    InModule.AddPrivateDependencyModule("UElibPNG");
                    InModule.AddPublicDependencyModule("UEOgg");
                    InModule.AddPublicDependencyModule("Vorbis");
                }

                if (InModule.ToString() == "NetworkFile")
                {
                    if (EnableHTTPForNFS)
                    {
                        InModule.AddPublicDefinition("ENABLE_HTTP_FOR_NFS=1");
                        if (Target.Architecture == "-win32")
                        {
                            InModule.AddPrivateDependencyModule("HTML5Win32");
                        }
                        else
                        {
                            InModule.AddPrivateDependencyModule("HTML5JS");
                        }
                    }
                }
            }
            else if (Target.Platform == UnrealTargetPlatform.Win32 || Target.Platform == UnrealTargetPlatform.Win64 || Target.Platform == UnrealTargetPlatform.Mac)
            {
                // allow standalone tools to use targetplatform modules, without needing Engine
                if ((!UEBuildConfiguration.bBuildRequiresCookedData &&
                     InModule.ToString() == "Engine" &&
                     UEBuildConfiguration.bBuildDeveloperTools) ||
                    UEBuildConfiguration.bForceBuildTargetPlatforms)
                {
                    InModule.AddPlatformSpecificDynamicallyLoadedModule("HTML5TargetPlatform");
                }

                if (EnableHTTPForNFS && (Target.Platform == UnrealTargetPlatform.Win64 ||
                                         Target.Platform == UnrealTargetPlatform.Mac)
                    )
                {
                    if (InModule.ToString() == "NetworkFile") // client
                    {
                        InModule.AddPrivateDependencyModule("HTTP");
                        InModule.AddPublicDefinition("ENABLE_HTTP_FOR_NFS=1");
                    }
                    else if (InModule.ToString() == "NetworkFileSystem") // server
                    {
                        if (UnrealBuildTool.RunningRocket() == false ||
                            Target.Type == TargetRules.TargetType.Game)
                        {
                            InModule.AddPrivateDependencyModule("WebSockets");
                            InModule.AddPublicDefinition("ENABLE_HTTP_FOR_NFS=1");
                        }
                    }
                }
            }
        }
        /**
         *	Modify the newly created module passed in for this platform.
         *	This is not required - but allows for hiding details of a
         *	particular platform.
         *
         *	@param	InModule		The newly loaded module
         *	@param	Target			The target being build
         */
        public override void ModifyNewlyLoadedModule(UEBuildModule InModule, TargetInfo Target)
        {
            if ((Target.Platform == UnrealTargetPlatform.WinRT) ||
                (Target.Platform == UnrealTargetPlatform.WinRT_ARM))
            {
                if (InModule.ToString() == "Core")
                {
                    InModule.AddPublicIncludePath("Runtime/Core/Public/WinRT");
                    InModule.AddPublicDependencyModule("zlib");
                }
                else if (InModule.ToString() == "Engine")
                {
                    InModule.AddPrivateDependencyModule("zlib");
                    InModule.AddPrivateDependencyModule("UElibPNG");
                    InModule.AddPublicDependencyModule("UEOgg");
                    InModule.AddPublicDependencyModule("Vorbis");
                }
                else if (InModule.ToString() == "Launch")
                {
                }
                else if (InModule.ToString() == "D3D11RHI")
                {
                    InModule.AddPublicDefinition("D3D11_CUSTOM_VIEWPORT_CONSTRUCTOR=1");
                    // To enable platform specific D3D11 RHI Types
                    InModule.AddPrivateIncludePath("Runtime/Windows/D3D11RHI/Private/WinRT");
                    // Hack to enable AllowWindowsPlatformTypes.h/HideWindowsPlatformTypes.h
                    InModule.AddPublicIncludePath("Runtime/Core/Public/Windows");
                }
                else if (InModule.ToString() == "Sockets")
                {
                    // Hack to enable AllowWindowsPlatformTypes.h/HideWindowsPlatformTypes.h
                    InModule.AddPublicIncludePath("Runtime/Core/Public/Windows");
                }
                else if (InModule.ToString() == "PhysX")
                {
                    string PhysXDir = UEBuildConfiguration.UEThirdPartySourceDirectory + "PhysX/PhysX-3.3/";

                    InModule.AddPublicIncludePath("include/foundation/WinRT");
                    if (Target.Platform == UnrealTargetPlatform.WinRT)
                    {
                        InModule.AddPublicLibraryPath(PhysXDir + "Lib/WinRT");
                    }
                    else
                    {
                        InModule.AddPublicLibraryPath(PhysXDir + "Lib/WinRT/ARM");
                    }

                    if (Target.Configuration == UnrealTargetConfiguration.Debug)
                    {
                        InModule.AddPublicAdditionalLibrary("PhysX3DEBUG.lib");
                        InModule.AddPublicAdditionalLibrary("PhysX3ExtensionsDEBUG.lib");
                        InModule.AddPublicAdditionalLibrary("PhysX3CookingDEBUG.lib");
                        InModule.AddPublicAdditionalLibrary("PhysX3CommonDEBUG.lib");
                        InModule.AddPublicAdditionalLibrary("PhysX3VehicleDEBUG.lib");
                        InModule.AddPublicAdditionalLibrary("PxTaskDEBUG.lib");
                        InModule.AddPublicAdditionalLibrary("PhysXVisualDebuggerSDKDEBUG.lib");
                        InModule.AddPublicAdditionalLibrary("PhysXProfileSDKDEBUG.lib");
                    }
                    else if (Target.Configuration == UnrealTargetConfiguration.Development)
                    {
                        InModule.AddPublicAdditionalLibrary("PhysX3PROFILE.lib");
                        InModule.AddPublicAdditionalLibrary("PhysX3ExtensionsPROFILE.lib");
                        InModule.AddPublicAdditionalLibrary("PhysX3CookingPROFILE.lib");
                        InModule.AddPublicAdditionalLibrary("PhysX3CommonPROFILE.lib");
                        InModule.AddPublicAdditionalLibrary("PhysX3VehiclePROFILE.lib");
                        InModule.AddPublicAdditionalLibrary("PxTaskPROFILE.lib");
                        InModule.AddPublicAdditionalLibrary("PhysXVisualDebuggerSDKPROFILE.lib");
                        InModule.AddPublicAdditionalLibrary("PhysXProfileSDKPROFILE.lib");
                    }
                    else // Test or Shipping
                    {
                        InModule.AddPublicAdditionalLibrary("PhysX3.lib");
                        InModule.AddPublicAdditionalLibrary("PhysX3Extensions.lib");
                        InModule.AddPublicAdditionalLibrary("PhysX3Cooking.lib");
                        InModule.AddPublicAdditionalLibrary("PhysX3Common.lib");
                        InModule.AddPublicAdditionalLibrary("PhysX3Vehicle.lib");
                        InModule.AddPublicAdditionalLibrary("PxTask.lib");
                        InModule.AddPublicAdditionalLibrary("PhysXVisualDebuggerSDK.lib");
                        InModule.AddPublicAdditionalLibrary("PhysXProfileSDK.lib");
                    }
                }
                else if (InModule.ToString() == "APEX")
                {
                    InModule.RemovePublicDefinition("APEX_STATICALLY_LINKED=0");
                    InModule.AddPublicDefinition("APEX_STATICALLY_LINKED=1");

                    string APEXDir = UEBuildConfiguration.UEThirdPartySourceDirectory + "PhysX/APEX-1.3/";
                    if (Target.Platform == UnrealTargetPlatform.WinRT)
                    {
                        InModule.AddPublicLibraryPath(APEXDir + "lib/WinRT");
                    }
                    else
                    {
                        InModule.AddPublicLibraryPath(APEXDir + "lib/WinRT/ARM");
                    }

                    if (Target.Configuration == UnrealTargetConfiguration.Debug)
                    {
                        InModule.AddPublicAdditionalLibrary("ApexCommonDEBUG.lib");
                        InModule.AddPublicAdditionalLibrary("ApexFrameworkDEBUG.lib");
                        InModule.AddPublicAdditionalLibrary("ApexSharedDEBUG.lib");
                        InModule.AddPublicAdditionalLibrary("APEX_DestructibleDEBUG.lib");
                    }
                    else if (Target.Configuration == UnrealTargetConfiguration.Development)
                    {
                        InModule.AddPublicAdditionalLibrary("ApexCommonPROFILE.lib");
                        InModule.AddPublicAdditionalLibrary("ApexFrameworkPROFILE.lib");
                        InModule.AddPublicAdditionalLibrary("ApexSharedPROFILE.lib");
                        InModule.AddPublicAdditionalLibrary("APEX_DestructiblePROFILE.lib");
                    }
                    else // Test or Shipping
                    {
                        InModule.AddPublicAdditionalLibrary("ApexCommon.lib");
                        InModule.AddPublicAdditionalLibrary("ApexFramework.lib");
                        InModule.AddPublicAdditionalLibrary("ApexShared.lib");
                        InModule.AddPublicAdditionalLibrary("APEX_Destructible.lib");
                    }
                }
                else if (InModule.ToString() == "FreeType2")
                {
                    string FreeType2Path = UEBuildConfiguration.UEThirdPartySourceDirectory + "FreeType2/FreeType2-2.4.12/";
                    if (Target.Platform == UnrealTargetPlatform.WinRT)
                    {
                        InModule.AddPublicLibraryPath(FreeType2Path + "Lib/WinRT/Win64");
                    }
                    else
                    {
                        InModule.AddPublicLibraryPath(FreeType2Path + "Lib/WinRT/ARM");
                    }
                    InModule.AddPublicAdditionalLibrary("freetype2412MT.lib");
                }
                else if (InModule.ToString() == "UElibPNG")
                {
                    string libPNGPath = UEBuildConfiguration.UEThirdPartySourceDirectory + "libPNG/libPNG-1.5.2";
                    if (Target.Platform == UnrealTargetPlatform.WinRT)
                    {
                        InModule.AddPublicLibraryPath(libPNGPath + "/lib/WinRT/Win64");
                    }
                    else
                    {
                        InModule.AddPublicLibraryPath(libPNGPath + "/lib/WinRT/ARM");
                    }
                    InModule.AddPublicAdditionalLibrary("libpng125.lib");
                }
                else if (InModule.ToString() == "DX11")
                {
                    // Clear out all the Windows include paths and libraries...
                    // The WinRTSDK module handles proper paths and libs for WinRT.
                    // However, the D3D11RHI module will include the DX11 module.
                    InModule.ClearPublicIncludePaths();
                    InModule.ClearPublicLibraryPaths();
                    InModule.ClearPublicAdditionalLibraries();
                    InModule.RemovePublicDefinition("WITH_D3DX_LIBS=1");
                    InModule.AddPublicDefinition("D3D11_WITH_DWMAPI=0");
                    InModule.AddPublicDefinition("WITH_D3DX_LIBS=0");
                    InModule.AddPublicDefinition("WITH_DX_PERF=0");
                    InModule.RemovePublicAdditionalLibrary("X3DAudio.lib");
                    InModule.RemovePublicAdditionalLibrary("XAPOFX.lib");
                }
                else if (InModule.ToString() == "XInput")
                {
                    InModule.AddPublicAdditionalLibrary("XInput.lib");
                }
                else if (InModule.ToString() == "XAudio2")
                {
                    InModule.AddPublicDefinition("XAUDIO_SUPPORTS_XMA2WAVEFORMATEX=0");
                    InModule.AddPublicDefinition("XAUDIO_SUPPORTS_DEVICE_DETAILS=0");
                    InModule.AddPublicDefinition("XAUDIO2_SUPPORTS_MUSIC=0");
                    InModule.AddPublicDefinition("XAUDIO2_SUPPORTS_SENDLIST=0");
                    InModule.AddPublicAdditionalLibrary("XAudio2.lib");
                    // Hack to enable AllowWindowsPlatformTypes.h/HideWindowsPlatformTypes.h
                    InModule.AddPublicIncludePath("Runtime/Core/Public/Windows");
                }
                else if (InModule.ToString() == "UEOgg")
                {
                    string OggPath = UEBuildConfiguration.UEThirdPartySourceDirectory + "Ogg/libogg-1.2.2/";
                    if (Target.Platform == UnrealTargetPlatform.WinRT)
                    {
                        InModule.AddPublicLibraryPath(OggPath + "WinRT/VS2012/WinRT/x64/Release");
                    }
                    else
                    {
                        InModule.AddPublicLibraryPath(OggPath + "WinRT/VS2012/WinRT/ARM/Release");
                    }
                    InModule.AddPublicAdditionalLibrary("libogg_static.lib");
                }
                else if (InModule.ToString() == "Vorbis")
                {
                    string VorbisPath = UEBuildConfiguration.UEThirdPartySourceDirectory + "Vorbis/libvorbis-1.3.2/";
                    if (Target.Platform == UnrealTargetPlatform.WinRT)
                    {
                        InModule.AddPublicLibraryPath(VorbisPath + "WinRT/VS2012/WinRT/x64/Release");
                    }
                    else
                    {
                        InModule.AddPublicLibraryPath(VorbisPath + "WinRT/VS2012/WinRT/ARM/Release");
                    }
                    InModule.AddPublicAdditionalLibrary("libvorbis_static.lib");
                }
                else if (InModule.ToString() == "VorbisFile")
                {
                    string VorbisPath = UEBuildConfiguration.UEThirdPartySourceDirectory + "Vorbis/libvorbis-1.3.2/";
                    if (Target.Platform == UnrealTargetPlatform.WinRT)
                    {
                        InModule.AddPublicLibraryPath(VorbisPath + "WinRT/VS2012/WinRT/x64/Release");
                    }
                    else
                    {
                        InModule.AddPublicLibraryPath(VorbisPath + "WinRT/VS2012/WinRT/ARM/Release");
                    }
                    InModule.AddPublicAdditionalLibrary("libvorbisfile_static.lib");
                }
                else if (InModule.ToString() == "DX11Audio")
                {
                    InModule.RemovePublicAdditionalLibrary("X3DAudio.lib");
                    InModule.RemovePublicAdditionalLibrary("XAPOFX.lib");
                }
                else if (InModule.ToString() == "zlib")
                {
                    if (Target.Platform == UnrealTargetPlatform.WinRT)
                    {
                        InModule.AddPublicLibraryPath(UEBuildConfiguration.UEThirdPartySourceDirectory + "zlib/zlib-1.2.5/Lib/WinRT/Win64");
                    }
                    else
                    {
                        InModule.AddPublicLibraryPath(UEBuildConfiguration.UEThirdPartySourceDirectory + "zlib/zlib-1.2.5/Lib/WinRT/ARM");
                    }
                    InModule.AddPublicAdditionalLibrary("zlib125.lib");
                }
            }
            else if ((Target.Platform == UnrealTargetPlatform.Win32) || (Target.Platform == UnrealTargetPlatform.Win64))
            {
//              bool bBuildShaderFormats = UEBuildConfiguration.bForceBuildShaderFormats;
//              if (!UEBuildConfiguration.bBuildRequiresCookedData)
//              {
//                  if (InModule.ToString() == "Engine")
//                  {
//                      if (UEBuildConfiguration.bBuildDeveloperTools)
//                      {
                //                          InModule.AddPlatformSpecificDynamicallyLoadedModule("WinRTTargetPlatform");
//                      }
//                  }
//                  else if (InModule.ToString() == "TargetPlatform")
//                  {
//                      bBuildShaderFormats = true;
//                  }
//              }

//              // allow standalone tools to use targetplatform modules, without needing Engine
//              if (UEBuildConfiguration.bForceBuildTargetPlatforms)
//              {
                //                  InModule.AddPlatformSpecificDynamicallyLoadedModule("WinRTTargetPlatform");
//              }

//              if (bBuildShaderFormats)
//              {
                //                  InModule.AddPlatformSpecificDynamicallyLoadedModule("ShaderFormatWinRT");
//              }
            }
        }
Exemple #14
0
        /**
         *	Modify the newly created module passed in for this platform.
         *	This is not required - but allows for hiding details of a
         *	particular platform.
         *	
         *	@param	InModule		The newly loaded module
         *	@param	Target			The target being build
         */
        public override void ModifyNewlyLoadedModule(UEBuildModule InModule, TargetInfo Target)
        {
			if (Target.Platform == UnrealTargetPlatform.HTML5)
            {
                if (InModule.ToString() == "Core")
                {
                    InModule.AddPublicIncludePath("Runtime/Core/Public/HTML5");
                    InModule.AddPublicDependencyModule("zlib");
                }
                else if (InModule.ToString() == "Engine")
                {
                    InModule.AddPrivateDependencyModule("zlib");
                    InModule.AddPrivateDependencyModule("UElibPNG");
                    InModule.AddPublicDependencyModule("UEOgg");
                    InModule.AddPublicDependencyModule("Vorbis");
                }

                if (InModule.ToString() == "NetworkFile")
                {
                    if (EnableHTTPForNFS)
                    {   
                        InModule.AddPublicDefinition("ENABLE_HTTP_FOR_NFS=1");
                        if (Target.Architecture == "-win32")
                        {
                            InModule.AddPrivateDependencyModule("HTML5Win32");
                        }
                        else
                        {
                            InModule.AddPrivateDependencyModule("HTML5JS");
                        }
                    }
                }
            }
            else if (Target.Platform == UnrealTargetPlatform.Win32 || Target.Platform == UnrealTargetPlatform.Win64 || Target.Platform == UnrealTargetPlatform.Mac )
            {
				// allow standalone tools to use targetplatform modules, without needing Engine
				if ((!UEBuildConfiguration.bBuildRequiresCookedData
                    && InModule.ToString() == "Engine"
                    && UEBuildConfiguration.bBuildDeveloperTools)
                    || UEBuildConfiguration.bForceBuildTargetPlatforms)
                {
                    InModule.AddPlatformSpecificDynamicallyLoadedModule("HTML5TargetPlatform");
                }

                if (EnableHTTPForNFS && (Target.Platform == UnrealTargetPlatform.Win64  
                                         || Target.Platform == UnrealTargetPlatform.Mac)
                    )
                {
                    if (InModule.ToString() == "NetworkFile") // client
                    {
                        InModule.AddPrivateDependencyModule("HTTP");
                        InModule.AddPublicDefinition("ENABLE_HTTP_FOR_NFS=1");
                    }
                    else if (InModule.ToString() == "NetworkFileSystem") // server 
                    {
                        if (UnrealBuildTool.RunningRocket() == false || 
                            Target.Type == TargetRules.TargetType.Game )
                        {
                            InModule.AddPrivateDependencyModule("WebSockets");
                            InModule.AddPublicDefinition("ENABLE_HTTP_FOR_NFS=1");
                        }
                    }
                }
            }
        }
        /**
         *	Modify the newly created module passed in for this platform.
         *	This is not required - but allows for hiding details of a
         *	particular platform.
         *
         *	@param	InModule		The newly loaded module
         *	@param	Target			The target being build
         */
        public override void ModifyNewlyLoadedModule(UEBuildModule InModule, TargetInfo Target)
        {
            if ((Target.Platform == UnrealTargetPlatform.WinRT) ||
                (Target.Platform == UnrealTargetPlatform.WinRT_ARM))
            {
                if (InModule.ToString() == "Core")
                {
                    InModule.AddPublicIncludePath("Runtime/Core/Public/WinRT");
                    InModule.AddPublicDependencyModule("zlib");
                }
                else if (InModule.ToString() == "Engine")
                {
                    InModule.AddPrivateDependencyModule("zlib");
                    InModule.AddPrivateDependencyModule("UElibPNG");
                    InModule.AddPublicDependencyModule("UEOgg");
                    InModule.AddPublicDependencyModule("Vorbis");
                }
                else if (InModule.ToString() == "Launch")
                {
                }
                else if (InModule.ToString() == "D3D11RHI")
                {
                    InModule.AddPublicDefinition("D3D11_CUSTOM_VIEWPORT_CONSTRUCTOR=1");
                    // To enable platform specific D3D11 RHI Types
                    InModule.AddPrivateIncludePath("Runtime/Windows/D3D11RHI/Private/WinRT");
                    // Hack to enable AllowWindowsPlatformTypes.h/HideWindowsPlatformTypes.h
                    InModule.AddPublicIncludePath("Runtime/Core/Public/Windows");
                }
                else if (InModule.ToString() == "Sockets")
                {
                    // Hack to enable AllowWindowsPlatformTypes.h/HideWindowsPlatformTypes.h
                    InModule.AddPublicIncludePath("Runtime/Core/Public/Windows");
                }
                else if (InModule.ToString() == "PhysX")
                {
                    string PhysXDir = UEBuildConfiguration.UEThirdPartySourceDirectory + "PhysX/PhysX-3.3/";

                    InModule.AddPublicIncludePath("include/foundation/WinRT");
                    if (Target.Platform == UnrealTargetPlatform.WinRT)
                    {
                        InModule.AddPublicLibraryPath(PhysXDir + "Lib/WinRT");
                    }
                    else
                    {
                        InModule.AddPublicLibraryPath(PhysXDir + "Lib/WinRT/ARM");
                    }

                    if (Target.Configuration == UnrealTargetConfiguration.Debug)
                    {
                        InModule.AddPublicAdditionalLibrary("PhysX3DEBUG.lib");
                        InModule.AddPublicAdditionalLibrary("PhysX3ExtensionsDEBUG.lib");
                        InModule.AddPublicAdditionalLibrary("PhysX3CookingDEBUG.lib");
                        InModule.AddPublicAdditionalLibrary("PhysX3CommonDEBUG.lib");
                        InModule.AddPublicAdditionalLibrary("PhysX3VehicleDEBUG.lib");
                        InModule.AddPublicAdditionalLibrary("PxTaskDEBUG.lib");
                        InModule.AddPublicAdditionalLibrary("PhysXVisualDebuggerSDKDEBUG.lib");
                        InModule.AddPublicAdditionalLibrary("PhysXProfileSDKDEBUG.lib");
                    }
                    else if (Target.Configuration == UnrealTargetConfiguration.Development)
                    {
                        InModule.AddPublicAdditionalLibrary("PhysX3PROFILE.lib");
                        InModule.AddPublicAdditionalLibrary("PhysX3ExtensionsPROFILE.lib");
                        InModule.AddPublicAdditionalLibrary("PhysX3CookingPROFILE.lib");
                        InModule.AddPublicAdditionalLibrary("PhysX3CommonPROFILE.lib");
                        InModule.AddPublicAdditionalLibrary("PhysX3VehiclePROFILE.lib");
                        InModule.AddPublicAdditionalLibrary("PxTaskPROFILE.lib");
                        InModule.AddPublicAdditionalLibrary("PhysXVisualDebuggerSDKPROFILE.lib");
                        InModule.AddPublicAdditionalLibrary("PhysXProfileSDKPROFILE.lib");
                    }
                    else // Test or Shipping
                    {
                        InModule.AddPublicAdditionalLibrary("PhysX3.lib");
                        InModule.AddPublicAdditionalLibrary("PhysX3Extensions.lib");
                        InModule.AddPublicAdditionalLibrary("PhysX3Cooking.lib");
                        InModule.AddPublicAdditionalLibrary("PhysX3Common.lib");
                        InModule.AddPublicAdditionalLibrary("PhysX3Vehicle.lib");
                        InModule.AddPublicAdditionalLibrary("PxTask.lib");
                        InModule.AddPublicAdditionalLibrary("PhysXVisualDebuggerSDK.lib");
                        InModule.AddPublicAdditionalLibrary("PhysXProfileSDK.lib");
                    }
                }
                else if (InModule.ToString() == "APEX")
                {
                    InModule.RemovePublicDefinition("APEX_STATICALLY_LINKED=0");
                    InModule.AddPublicDefinition("APEX_STATICALLY_LINKED=1");

                    string APEXDir = UEBuildConfiguration.UEThirdPartySourceDirectory + "PhysX/APEX-1.3/";
                    if (Target.Platform == UnrealTargetPlatform.WinRT)
                    {
                        InModule.AddPublicLibraryPath(APEXDir + "lib/WinRT");
                    }
                    else
                    {
                        InModule.AddPublicLibraryPath(APEXDir + "lib/WinRT/ARM");
                    }

                    if (Target.Configuration == UnrealTargetConfiguration.Debug)
                    {
                        InModule.AddPublicAdditionalLibrary("ApexCommonDEBUG.lib");
                        InModule.AddPublicAdditionalLibrary("ApexFrameworkDEBUG.lib");
                        InModule.AddPublicAdditionalLibrary("ApexSharedDEBUG.lib");
                        InModule.AddPublicAdditionalLibrary("APEX_DestructibleDEBUG.lib");

                    }
                    else if (Target.Configuration == UnrealTargetConfiguration.Development)
                    {
                        InModule.AddPublicAdditionalLibrary("ApexCommonPROFILE.lib");
                        InModule.AddPublicAdditionalLibrary("ApexFrameworkPROFILE.lib");
                        InModule.AddPublicAdditionalLibrary("ApexSharedPROFILE.lib");
                        InModule.AddPublicAdditionalLibrary("APEX_DestructiblePROFILE.lib");
                    }
                    else // Test or Shipping
                    {
                        InModule.AddPublicAdditionalLibrary("ApexCommon.lib");
                        InModule.AddPublicAdditionalLibrary("ApexFramework.lib");
                        InModule.AddPublicAdditionalLibrary("ApexShared.lib");
                        InModule.AddPublicAdditionalLibrary("APEX_Destructible.lib");
                    }
                }
                else if (InModule.ToString() == "FreeType2")
                {
                    string FreeType2Path = UEBuildConfiguration.UEThirdPartySourceDirectory + "FreeType2/FreeType2-2.4.12/";
                    if (Target.Platform == UnrealTargetPlatform.WinRT)
                    {
                        InModule.AddPublicLibraryPath(FreeType2Path + "Lib/WinRT/Win64");
                    }
                    else
                    {
                        InModule.AddPublicLibraryPath(FreeType2Path + "Lib/WinRT/ARM");
                    }
                    InModule.AddPublicAdditionalLibrary("freetype2412MT.lib");
                }
                else if (InModule.ToString() == "UElibPNG")
                {
                    string libPNGPath = UEBuildConfiguration.UEThirdPartySourceDirectory + "libPNG/libPNG-1.5.2";
                    if (Target.Platform == UnrealTargetPlatform.WinRT)
                    {
                        InModule.AddPublicLibraryPath(libPNGPath + "/lib/WinRT/Win64");
                    }
                    else
                    {
                        InModule.AddPublicLibraryPath(libPNGPath + "/lib/WinRT/ARM");
                    }
                    InModule.AddPublicAdditionalLibrary("libpng125.lib");
                }
                else if (InModule.ToString() == "DX11")
                {
                    // Clear out all the Windows include paths and libraries...
                    // The WinRTSDK module handles proper paths and libs for WinRT.
                    // However, the D3D11RHI module will include the DX11 module.
                    InModule.ClearPublicIncludePaths();
                    InModule.ClearPublicLibraryPaths();
                    InModule.ClearPublicAdditionalLibraries();
                    InModule.RemovePublicDefinition("WITH_D3DX_LIBS=1");
                    InModule.AddPublicDefinition("D3D11_WITH_DWMAPI=0");
                    InModule.AddPublicDefinition("WITH_D3DX_LIBS=0");
                    InModule.AddPublicDefinition("WITH_DX_PERF=0");
                    InModule.RemovePublicAdditionalLibrary("X3DAudio.lib");
                    InModule.RemovePublicAdditionalLibrary("XAPOFX.lib");
                }
                else if (InModule.ToString() == "XInput")
                {
                    InModule.AddPublicAdditionalLibrary("XInput.lib");
                }
                else if (InModule.ToString() == "XAudio2")
                {
                    InModule.AddPublicDefinition("XAUDIO_SUPPORTS_XMA2WAVEFORMATEX=0");
                    InModule.AddPublicDefinition("XAUDIO_SUPPORTS_DEVICE_DETAILS=0");
                    InModule.AddPublicDefinition("XAUDIO2_SUPPORTS_MUSIC=0");
                    InModule.AddPublicDefinition("XAUDIO2_SUPPORTS_SENDLIST=0");
                    InModule.AddPublicAdditionalLibrary("XAudio2.lib");
                    // Hack to enable AllowWindowsPlatformTypes.h/HideWindowsPlatformTypes.h
                    InModule.AddPublicIncludePath("Runtime/Core/Public/Windows");
                }
                else if (InModule.ToString() == "UEOgg")
                {
                    string OggPath = UEBuildConfiguration.UEThirdPartySourceDirectory + "Ogg/libogg-1.2.2/";
                    if (Target.Platform == UnrealTargetPlatform.WinRT)
                    {
                        InModule.AddPublicLibraryPath(OggPath + "WinRT/VS2012/WinRT/x64/Release");
                    }
                    else
                    {
                        InModule.AddPublicLibraryPath(OggPath + "WinRT/VS2012/WinRT/ARM/Release");
                    }
                    InModule.AddPublicAdditionalLibrary("libogg_static.lib");
                }
                else if (InModule.ToString() == "Vorbis")
                {
                    string VorbisPath = UEBuildConfiguration.UEThirdPartySourceDirectory + "Vorbis/libvorbis-1.3.2/";
                    if (Target.Platform == UnrealTargetPlatform.WinRT)
                    {
                        InModule.AddPublicLibraryPath(VorbisPath + "WinRT/VS2012/WinRT/x64/Release");
                    }
                    else
                    {
                        InModule.AddPublicLibraryPath(VorbisPath + "WinRT/VS2012/WinRT/ARM/Release");
                    }
                    InModule.AddPublicAdditionalLibrary("libvorbis_static.lib");
                }
                else if (InModule.ToString() == "VorbisFile")
                {
                    string VorbisPath = UEBuildConfiguration.UEThirdPartySourceDirectory + "Vorbis/libvorbis-1.3.2/";
                    if (Target.Platform == UnrealTargetPlatform.WinRT)
                    {
                        InModule.AddPublicLibraryPath(VorbisPath + "WinRT/VS2012/WinRT/x64/Release");
                    }
                    else
                    {
                        InModule.AddPublicLibraryPath(VorbisPath + "WinRT/VS2012/WinRT/ARM/Release");
                    }
                    InModule.AddPublicAdditionalLibrary("libvorbisfile_static.lib");
                }
                else if (InModule.ToString() == "DX11Audio")
                {
                    InModule.RemovePublicAdditionalLibrary("X3DAudio.lib");
                    InModule.RemovePublicAdditionalLibrary("XAPOFX.lib");
                }
                else if (InModule.ToString() == "zlib")
                {
                    if (Target.Platform == UnrealTargetPlatform.WinRT)
                    {
                        InModule.AddPublicLibraryPath(UEBuildConfiguration.UEThirdPartySourceDirectory + "zlib/zlib-1.2.5/Lib/WinRT/Win64");
                    }
                    else
                    {
                        InModule.AddPublicLibraryPath(UEBuildConfiguration.UEThirdPartySourceDirectory + "zlib/zlib-1.2.5/Lib/WinRT/ARM");
                    }
                    InModule.AddPublicAdditionalLibrary("zlib125.lib");
                }
            }
            else if ((Target.Platform == UnrealTargetPlatform.Win32) || (Target.Platform == UnrealTargetPlatform.Win64))
            {
            //              bool bBuildShaderFormats = UEBuildConfiguration.bForceBuildShaderFormats;
            // 				if (!UEBuildConfiguration.bBuildRequiresCookedData)
            // 				{
            // 					if (InModule.ToString() == "Engine")
            // 					{
            // 						if (UEBuildConfiguration.bBuildDeveloperTools)
            // 						{
                // 							InModule.AddPlatformSpecificDynamicallyLoadedModule("WinRTTargetPlatform");
            // 						}
            // 					}
            // 					else if (InModule.ToString() == "TargetPlatform")
            // 					{
            // 		                bBuildShaderFormats = true;
            // 					}
            // 				}

            // 				// allow standalone tools to use targetplatform modules, without needing Engine
            // 				if (UEBuildConfiguration.bForceBuildTargetPlatforms)
            // 				{
                // 					InModule.AddPlatformSpecificDynamicallyLoadedModule("WinRTTargetPlatform");
            // 				}

            //              if (bBuildShaderFormats)
            //              {
                //                  InModule.AddPlatformSpecificDynamicallyLoadedModule("ShaderFormatWinRT");
            //              }
            }
        }
Exemple #16
0
 /**
  *	Modify the newly created module passed in for this platform.
  *	This is not required - but allows for hiding details of a
  *	particular platform.
  *
  *	@param	InModule		The newly loaded module
  *	@param	Target			The target being build
  */
 public override void ModifyNewlyLoadedModule(UEBuildModule InModule, TargetInfo Target)
 {
     if (Target.Platform == UnrealTargetPlatform.HTML5)
     {
         if (InModule.ToString() == "Core")
         {
             InModule.AddPublicIncludePath("Runtime/Core/Public/HTML5");
             InModule.AddPublicDependencyModule("zlib");
         }
         else if (InModule.ToString() == "Engine")
         {
             InModule.AddPrivateDependencyModule("zlib");
             InModule.AddPrivateDependencyModule("UElibPNG");
             InModule.AddPublicDependencyModule("UEOgg");
             InModule.AddPublicDependencyModule("Vorbis");
         }
     }
     else if (Target.Platform == UnrealTargetPlatform.Win32 || Target.Platform == UnrealTargetPlatform.Win64 || Target.Platform == UnrealTargetPlatform.Mac )
     {
         // allow standalone tools to use targetplatform modules, without needing Engine
         if ((!UEBuildConfiguration.bBuildRequiresCookedData
             && InModule.ToString() == "Engine"
             && UEBuildConfiguration.bBuildDeveloperTools)
             || UEBuildConfiguration.bForceBuildTargetPlatforms)
         {
             InModule.AddPlatformSpecificDynamicallyLoadedModule("HTML5TargetPlatform");
         }
     }
 }
Exemple #17
-1
        public override void ModifyNewlyLoadedModule(UEBuildModule InModule, TargetInfo Target)
        {
            if ((Target.Platform == UnrealTargetPlatform.Win32) || (Target.Platform == UnrealTargetPlatform.Win64))
            {
                bool bBuildShaderFormats = UEBuildConfiguration.bForceBuildShaderFormats;

                if (!UEBuildConfiguration.bBuildRequiresCookedData)
                {
                    if (InModule.ToString() == "TargetPlatform")
                    {
                        bBuildShaderFormats = true;
                    }
                }

                // allow standalone tools to use target platform modules, without needing Engine
                if (UEBuildConfiguration.bForceBuildTargetPlatforms)
                {
                    InModule.AddDynamicallyLoadedModule("WindowsTargetPlatform");
                    InModule.AddDynamicallyLoadedModule("WindowsNoEditorTargetPlatform");
                    InModule.AddDynamicallyLoadedModule("WindowsServerTargetPlatform");
                    InModule.AddDynamicallyLoadedModule("WindowsClientTargetPlatform");
					InModule.AddDynamicallyLoadedModule("AllDesktopTargetPlatform");
                }

                if (bBuildShaderFormats)
                {
                    InModule.AddDynamicallyLoadedModule("ShaderFormatD3D");
                    InModule.AddDynamicallyLoadedModule("ShaderFormatOpenGL");

//#todo-rco: Remove when public
					{
						string VulkanSDKPath = Environment.GetEnvironmentVariable("VulkanSDK");
						if (!String.IsNullOrEmpty(VulkanSDKPath))
						{
							InModule.AddDynamicallyLoadedModule("VulkanShaderFormat");
						}
					}
				}

                if (InModule.ToString() == "D3D11RHI")
                {
                    // To enable platform specific D3D11 RHI Types
                    InModule.AddPrivateIncludePath("Runtime/Windows/D3D11RHI/Private/Windows");
                }

				if (InModule.ToString() == "D3D12RHI")
				{
					// To enable platform specific D3D12 RHI Types
					InModule.AddPrivateIncludePath("Runtime/Windows/D3D12RHI/Private/Windows");
				}
			}
        }
Exemple #18
-1
        /**
         *	Modify the newly created module passed in for this platform.
         *	This is not required - but allows for hiding details of a
         *	particular platform.
         *
         *	@param	InModule		The newly loaded module
         *	@param	Target			The target being build
         */
        public override void ModifyNewlyLoadedModule(UEBuildModule InModule, TargetInfo Target)
        {
            if ((Target.Platform == UnrealTargetPlatform.Win32) || (Target.Platform == UnrealTargetPlatform.Win64))
            {
                if (!UEBuildConfiguration.bBuildRequiresCookedData)
                {
                    if (InModule.ToString() == "Engine")
                    {
                        if (UEBuildConfiguration.bBuildDeveloperTools)
                        {
                            InModule.AddPlatformSpecificDynamicallyLoadedModule("LinuxTargetPlatform");
                            InModule.AddPlatformSpecificDynamicallyLoadedModule("LinuxNoEditorTargetPlatform");
                            InModule.AddPlatformSpecificDynamicallyLoadedModule("LinuxServerTargetPlatform");
                        }
                    }
                }

                // allow standalone tools to use targetplatform modules, without needing Engine
                if (UEBuildConfiguration.bForceBuildTargetPlatforms)
                {
                    InModule.AddPlatformSpecificDynamicallyLoadedModule("LinuxTargetPlatform");
                    InModule.AddPlatformSpecificDynamicallyLoadedModule("LinuxNoEditorTargetPlatform");
                    InModule.AddPlatformSpecificDynamicallyLoadedModule("LinuxServerTargetPlatform");
                }
            }
            else if (Target.Platform == UnrealTargetPlatform.Linux)
            {
                bool bBuildShaderFormats = UEBuildConfiguration.bForceBuildShaderFormats;

                if (!UEBuildConfiguration.bBuildRequiresCookedData)
                {
                    if (InModule.ToString() == "TargetPlatform")
                    {
                        bBuildShaderFormats = true;
                    }
                }

                // allow standalone tools to use target platform modules, without needing Engine
                if (UEBuildConfiguration.bForceBuildTargetPlatforms)
                {
                    InModule.AddDynamicallyLoadedModule("LinuxTargetPlatform");
                    InModule.AddDynamicallyLoadedModule("LinuxNoEditorTargetPlatform");
                    InModule.AddDynamicallyLoadedModule("LinuxServerTargetPlatform");
                    InModule.AddDynamicallyLoadedModule("AllDesktopTargetPlatform");
                }

                if (bBuildShaderFormats)
                {
                    // InModule.AddDynamicallyLoadedModule("ShaderFormatD3D");
                    InModule.AddDynamicallyLoadedModule("ShaderFormatOpenGL");
                }
            }
        }
        public override void ModifyNewlyLoadedModule(UEBuildModule InModule, TargetInfo Target)
        {
            if ((Target.Platform == UnrealTargetPlatform.Win32) || (Target.Platform == UnrealTargetPlatform.Win64))
            {
                bool bBuildShaderFormats = UEBuildConfiguration.bForceBuildShaderFormats;
                if (!UEBuildConfiguration.bBuildRequiresCookedData)
                {
                    if (InModule.ToString() == "Engine")
                    {
                        if (UEBuildConfiguration.bBuildDeveloperTools)
                        {
                            InModule.AddPlatformSpecificDynamicallyLoadedModule("AndroidTargetPlatform");
                            InModule.AddPlatformSpecificDynamicallyLoadedModule("Android_PVRTCTargetPlatform");
                            InModule.AddPlatformSpecificDynamicallyLoadedModule("Android_ATCTargetPlatform");
                            InModule.AddPlatformSpecificDynamicallyLoadedModule("Android_DXTTargetPlatform");
                            InModule.AddPlatformSpecificDynamicallyLoadedModule("Android_ETC1TargetPlatform");
                            InModule.AddPlatformSpecificDynamicallyLoadedModule("Android_ETC2TargetPlatform");
            //                            InModule.AddPlatformSpecificDynamicallyLoadedModule("Android_GL4TargetPlatform");
                            // @todo es31: Put this back in for ES31 support
                            // ES31 code is in, but it's not fully supported in UE4 4.5, so for now we need to disable the targetplatform as it will confuse people greatly
                            // InModule.AddPlatformSpecificDynamicallyLoadedModule("Android_ES31TargetPlatform");
                        }
                    }
                    else if (InModule.ToString() == "UnrealEd")
                    {
                        InModule.AddPlatformSpecificDynamicallyLoadedModule("AndroidPlatformEditor");
                    }
                    else if (InModule.ToString() == "TargetPlatform")
                    {
                        bBuildShaderFormats = true;
                        InModule.AddDynamicallyLoadedModule("TextureFormatPVR");
                        InModule.AddDynamicallyLoadedModule("TextureFormatDXT");
                        InModule.AddPlatformSpecificDynamicallyLoadedModule("TextureFormatAndroid");    // ATITC, ETC1 and ETC2
                        if (UEBuildConfiguration.bBuildDeveloperTools)
                        {
                            //InModule.AddDynamicallyLoadedModule("AudioFormatADPCM");	//@todo android: android audio
                        }
                    }
                }

                // allow standalone tools to use targetplatform modules, without needing Engine
                if (UEBuildConfiguration.bForceBuildTargetPlatforms)
                {
                    InModule.AddPlatformSpecificDynamicallyLoadedModule("AndroidTargetPlatform");
                    InModule.AddPlatformSpecificDynamicallyLoadedModule("Android_PVRTCTargetPlatform");
                    InModule.AddPlatformSpecificDynamicallyLoadedModule("Android_ATCTargetPlatform");
                    InModule.AddPlatformSpecificDynamicallyLoadedModule("Android_DXTTargetPlatform");
                    InModule.AddPlatformSpecificDynamicallyLoadedModule("Android_ETC1TargetPlatform");
                    InModule.AddPlatformSpecificDynamicallyLoadedModule("Android_ETC2TargetPlatform");
            //                    InModule.AddPlatformSpecificDynamicallyLoadedModule("Android_GL4TargetPlatform");
                    // @todo es31: Put this back in for ES31 support
                    // ES31 code is in, but it's not fully supported in UE4 4.5, so for now we need to disable the targetplatform as it will confuse people greatly
                    // InModule.AddPlatformSpecificDynamicallyLoadedModule("Android_ES31TargetPlatform");
                }

                if (bBuildShaderFormats)
                {
                    //InModule.AddDynamicallyLoadedModule("ShaderFormatAndroid");		//@todo android: ShaderFormatAndroid
                }
            }
        }
        public override void ModifyNewlyLoadedModule(UEBuildModule InModule, TargetInfo Target)
        {
            if ((Target.Platform == UnrealTargetPlatform.Win32) || (Target.Platform == UnrealTargetPlatform.Win64))
            {
                bool bBuildShaderFormats = UEBuildConfiguration.bForceBuildShaderFormats;

                if (!UEBuildConfiguration.bBuildRequiresCookedData)
                {
                    if (InModule.ToString() == "TargetPlatform")
                    {
                        bBuildShaderFormats = true;
                    }
                }

                // allow standalone tools to use target platform modules, without needing Engine
                if (UEBuildConfiguration.bForceBuildTargetPlatforms)
                {
                    InModule.AddDynamicallyLoadedModule("WindowsTargetPlatform");
                    InModule.AddDynamicallyLoadedModule("WindowsNoEditorTargetPlatform");
                    InModule.AddDynamicallyLoadedModule("WindowsServerTargetPlatform");
                    InModule.AddDynamicallyLoadedModule("WindowsClientTargetPlatform");
                }

                if (bBuildShaderFormats)
                {
                    InModule.AddDynamicallyLoadedModule("ShaderFormatD3D");
                    InModule.AddDynamicallyLoadedModule("ShaderFormatOpenGL");
                }

                if (InModule.ToString() == "D3D11RHI")
                {
                    // To enable platform specific D3D11 RHI Types
                    InModule.AddPrivateIncludePath("Runtime/Windows/D3D11RHI/Private/Windows");
                }
            }
        }
        public override void ModifyNewlyLoadedModule(UEBuildModule InModule, TargetInfo Target)
        {
            if ((Target.Platform == UnrealTargetPlatform.Win32) || (Target.Platform == UnrealTargetPlatform.Win64))
            {
                bool bBuildShaderFormats = UEBuildConfiguration.bForceBuildShaderFormats;
                if (!UEBuildConfiguration.bBuildRequiresCookedData)
                {
                    if (InModule.ToString() == "Engine")
                    {
                        if (UEBuildConfiguration.bBuildDeveloperTools)
                        {
                            InModule.AddPlatformSpecificDynamicallyLoadedModule("AndroidTargetPlatform");
                            InModule.AddPlatformSpecificDynamicallyLoadedModule("Android_PVRTCTargetPlatform");
                            InModule.AddPlatformSpecificDynamicallyLoadedModule("Android_ATCTargetPlatform");
                            InModule.AddPlatformSpecificDynamicallyLoadedModule("Android_DXTTargetPlatform");
                            InModule.AddPlatformSpecificDynamicallyLoadedModule("Android_ETC1TargetPlatform");
                            InModule.AddPlatformSpecificDynamicallyLoadedModule("Android_ETC2TargetPlatform");
                        }
                    }
                    else if (InModule.ToString() == "UnrealEd")
                    {
                        InModule.AddPlatformSpecificDynamicallyLoadedModule("AndroidPlatformEditor");
                    }
                    else if (InModule.ToString() == "TargetPlatform")
                    {
                        bBuildShaderFormats = true;
                        InModule.AddDynamicallyLoadedModule("TextureFormatPVR");
                        InModule.AddDynamicallyLoadedModule("TextureFormatDXT");
                        InModule.AddPlatformSpecificDynamicallyLoadedModule("TextureFormatAndroid");    // ATITC, ETC1 and ETC2
                        if (UEBuildConfiguration.bBuildDeveloperTools)
                        {
                            //InModule.AddDynamicallyLoadedModule("AudioFormatADPCM");	//@todo android: android audio
                        }
                    }
                }

                // allow standalone tools to use targetplatform modules, without needing Engine
                if (UEBuildConfiguration.bForceBuildTargetPlatforms)
                {
                    InModule.AddPlatformSpecificDynamicallyLoadedModule("AndroidTargetPlatform");
                    InModule.AddPlatformSpecificDynamicallyLoadedModule("Android_PVRTCTargetPlatform");
                    InModule.AddPlatformSpecificDynamicallyLoadedModule("Android_ATCTargetPlatform");
                    InModule.AddPlatformSpecificDynamicallyLoadedModule("Android_DXTTargetPlatform");
                    InModule.AddPlatformSpecificDynamicallyLoadedModule("Android_ETC1TargetPlatform");
                    InModule.AddPlatformSpecificDynamicallyLoadedModule("Android_ETC2TargetPlatform");
                }

                if (bBuildShaderFormats)
                {
                    //InModule.AddDynamicallyLoadedModule("ShaderFormatAndroid");		//@todo android: ShaderFormatAndroid
                }
            }
        }
Exemple #22
-1
		public override void ModifyNewlyLoadedModule(UEBuildModule InModule, TargetInfo Target)
		{
			if (Target.Platform == UnrealTargetPlatform.Mac)
			{
                bool bBuildShaderFormats = UEBuildConfiguration.bForceBuildShaderFormats;

                if (!UEBuildConfiguration.bBuildRequiresCookedData)
                {
                    if (InModule.ToString() == "TargetPlatform")
                    {
                        bBuildShaderFormats = true;
                    }
                }

				// allow standalone tools to use target platform modules, without needing Engine
				if (UEBuildConfiguration.bForceBuildTargetPlatforms)
				{
					InModule.AddDynamicallyLoadedModule("MacTargetPlatform");
					InModule.AddDynamicallyLoadedModule("MacNoEditorTargetPlatform");
					InModule.AddDynamicallyLoadedModule("MacClientTargetPlatform");
					InModule.AddDynamicallyLoadedModule("MacServerTargetPlatform");
					InModule.AddDynamicallyLoadedModule("AllDesktopTargetPlatform");
				}

                if (bBuildShaderFormats)
                {
					// InModule.AddDynamicallyLoadedModule("ShaderFormatD3D");
                    InModule.AddDynamicallyLoadedModule("ShaderFormatOpenGL");
                }
			}
		}
Exemple #23
-1
        /**
         *     Modify the newly created module passed in for this platform.
         *     This is not required - but allows for hiding details of a
         *     particular platform.
         *     
         *     @param InModule             The newly loaded module
         *     @param GameName             The game being build
         *     @param Target               The target being build
         */
        public override void ModifyNewlyLoadedModule(UEBuildModule InModule, TargetInfo Target)
        {
            if ((Target.Platform == UnrealTargetPlatform.Win32) || (Target.Platform == UnrealTargetPlatform.Win64) || (Target.Platform == UnrealTargetPlatform.Mac))
            {
                bool bBuildShaderFormats = UEBuildConfiguration.bForceBuildShaderFormats;
                if (!UEBuildConfiguration.bBuildRequiresCookedData)
                {
                    if (InModule.ToString() == "Engine")
                    {
                        if (UEBuildConfiguration.bBuildDeveloperTools)
                        {
                            InModule.AddPlatformSpecificDynamicallyLoadedModule("IOSTargetPlatform");
                        }
                    }
                    else if (InModule.ToString() == "TargetPlatform")
                    {
                        bBuildShaderFormats = true;
						InModule.AddDynamicallyLoadedModule("TextureFormatPVR");
						InModule.AddDynamicallyLoadedModule("TextureFormatASTC");
                        if (UEBuildConfiguration.bBuildDeveloperTools)
                        {
                            InModule.AddPlatformSpecificDynamicallyLoadedModule("AudioFormatADPCM");
                        }
                    }
                }

                // allow standalone tools to use targetplatform modules, without needing Engine
                if (UEBuildConfiguration.bForceBuildTargetPlatforms)
                {
                    InModule.AddPlatformSpecificDynamicallyLoadedModule("IOSTargetPlatform");
                }

                if (bBuildShaderFormats)
                {
                    InModule.AddPlatformSpecificDynamicallyLoadedModule("MetalShaderFormat");
                }
            }
        }