C# UEBuildBinaryType类代码示例

 /**
  *	Get the extension to use for the given binary type
  *
  *	@param	InBinaryType		The binrary type being built
  *
  *	@return	string				The binary extenstion (ie 'exe' or 'dll')
  */
 public override string GetBinaryExtension(UEBuildBinaryType InBinaryType)
 {
     if (GetActiveArchitecture() == "-win32")
     {
         switch (InBinaryType)
         {
             case UEBuildBinaryType.DynamicLinkLibrary:
                 return ".dll";
             case UEBuildBinaryType.Executable:
                 return ".exe";
             case UEBuildBinaryType.StaticLibrary:
                 return ".lib";
         }
         return base.GetBinaryExtension(InBinaryType);
     }
     else
     {
         if (InBinaryType == UEBuildBinaryType.StaticLibrary)
         {
             return ".bc";
         }
         else
         {
             return ".js";
         }
     }
 }

 /**
  *	Get the extension to use for the given binary type
  *
  *	@param	InBinaryType		The binary type being built
  *
  *	@return	string				The binary extension (i.e. 'exe' or 'dll')
  */
 public override string GetBinaryExtension(UEBuildBinaryType InBinaryType)
 {
     switch (InBinaryType)
     {
         case UEBuildBinaryType.DynamicLinkLibrary:
             return ".dll";
         case UEBuildBinaryType.Executable:
             return ".exe";
         case UEBuildBinaryType.StaticLibrary:
             return ".lib";
     }
     return base.GetBinaryExtension(InBinaryType);
 }

 /**
  *	Get the extension to use for the given binary type
  *
  *	@param	InBinaryType		The binary type being built
  *
  *	@return	string				The binary extension (i.e. 'exe' or 'dll')
  */
 public override string GetBinaryExtension(UEBuildBinaryType InBinaryType)
 {
     switch (InBinaryType)
     {
         case UEBuildBinaryType.DynamicLinkLibrary:
             return ".dll";
         case UEBuildBinaryType.Executable:
             return ".exe";
         case UEBuildBinaryType.StaticLibrary:
             return ".lib";
         case UEBuildBinaryType.Object:
             return ".obj";
         case UEBuildBinaryType.PrecompiledHeader:
             return ".pch";
     }
     return base.GetBinaryExtension(InBinaryType);
 }

        bool IsBuildingLibrary(UEBuildBinaryType Type)
        {
            if (BuildConfiguration.bRunUnrealCodeAnalyzer)
            {
                return false;
            }

            return Type == UEBuildBinaryType.StaticLibrary;
        }

		/**
		 *	Get the extension to use for debug info for the given binary type
		 *	
		 *	@param	InBinaryType		The binary type being built
		 *	
		 *	@return	string				The debug info extension (i.e. 'pdb')
		 */
		public override string GetDebugInfoExtension(UEBuildBinaryType InBinaryType)
		{
			switch (InBinaryType)
			{
				case UEBuildBinaryType.DynamicLinkLibrary:
					return BuildConfiguration.bGeneratedSYMFile || BuildConfiguration.bUsePDBFiles ? ".dsym" : "";
				case UEBuildBinaryType.Executable:
					return BuildConfiguration.bGeneratedSYMFile || BuildConfiguration.bUsePDBFiles ? ".dsym" : "";
				case UEBuildBinaryType.StaticLibrary:
					return "";
				case UEBuildBinaryType.Object:
					return "";
				case UEBuildBinaryType.PrecompiledHeader:
					return "";
				default:
					return "";
			}
		}

        /// <summary>
        /// The configuration class for a binary build.
        /// </summary>
        /// <param name="InType"></param>
        /// <param name="InOutputFilePath"></param>
        /// <param name="bInAllowExports"></param>
        /// <param name="bInCreateImportLibrarySeparately"></param>
        /// <param name="bInIsCrossTarget">For most binaries, this is false. If this is a cross-platform binary build for a specific platform (for example XB1 DLL for a windows editor) this will be true.</param>
        /// <param name="InProjectFilePath"></param>
        /// <param name="InModuleNames"></param>
        public UEBuildBinaryConfiguration(
				UEBuildBinaryType InType,
				string[] InOutputFilePaths = null,
				string InIntermediateDirectory = null,
				bool bInAllowExports = false,
				bool bInCreateImportLibrarySeparately = false,
				bool bInIncludeDependentLibrariesInLibrary = false,
				bool bInAllowCompilation = true,
				bool bInHasModuleRules = true,
                bool bInIsCrossTarget = false,
				string InProjectFilePath = "",
				List<string> InModuleNames = null
			)
        {
            Type = InType;
            OutputFilePaths = InOutputFilePaths != null ? (string[])InOutputFilePaths.Clone() : null;
            IntermediateDirectory = InIntermediateDirectory;
            bAllowExports = bInAllowExports;
            bCreateImportLibrarySeparately = bInCreateImportLibrarySeparately;
            bIncludeDependentLibrariesInLibrary = bInIncludeDependentLibrariesInLibrary;
            bAllowCompilation = bInAllowCompilation;
            bHasModuleRules = bInHasModuleRules;
            bIsCrossTarget = bInIsCrossTarget;
            ProjectFilePath = InProjectFilePath;
            if(InModuleNames != null)
            {
                ModuleNames.AddRange(InModuleNames);
            }
        }

		public override string GetDebugInfoExtension(UEBuildBinaryType InBinaryType)
		{
			if(BuildConfiguration.bGeneratedSYMFile)
			{
				return ".dSYM";
			}

			if(BuildConfiguration.bGeneratedSYMBundle)
			{
				return ".dSYM.zip";
			}

			return "";
		}

 /**
  *	Get the extension to use for debug info for the given binary type
  *
  *	@param	InBinaryType		The binary type being built
  *
  *	@return	string				The debug info extension (i.e. 'pdb')
  */
 public override string GetDebugInfoExtension(UEBuildBinaryType InBinaryType)
 {
     if (GetActiveArchitecture() == "-win32")
     {
         switch (InBinaryType)
         {
             case UEBuildBinaryType.DynamicLinkLibrary:
                 return ".pdb";
             case UEBuildBinaryType.Executable:
                 return ".pdb";
         }
         return "";
     }
     else
     {
         return "";
     }
 }

        /**
         *	Get the extension to use for the given binary type
         *	
         *	@param	InBinaryType		The binrary type being built
         *	
         *	@return	string				The binary extenstion (ie 'exe' or 'dll')
         */
        public override string GetBinaryExtension(UEBuildBinaryType InBinaryType)
        {
            switch (InBinaryType)
            {
                case UEBuildBinaryType.DynamicLinkLibrary: 
                    return ".dll";
                case UEBuildBinaryType.Executable:
                    return ".exe";
                case UEBuildBinaryType.StaticLibrary:
                    return ".lib";
                case UEBuildBinaryType.Object:
					if (!BuildConfiguration.bRunUnrealCodeAnalyzer)
					{
						return ".obj";
					}
					else
					{
						return @".includes";
					}
                case UEBuildBinaryType.PrecompiledHeader:
                    return ".pch";
            }
            return base.GetBinaryExtension(InBinaryType);
        }

		/// <summary>
		/// Get the extension to use for the given binary type
		/// </summary>
		/// <param name="InBinaryType"> The binary type being built</param>
		/// <returns>string    The binary extension (ie 'exe' or 'dll')</returns>
		public override string GetBinaryExtension(UEBuildBinaryType InBinaryType)
		{
			if (HTML5Architecture == "-win32")
			{
				switch (InBinaryType)
				{
					case UEBuildBinaryType.DynamicLinkLibrary:
						return ".dll";
					case UEBuildBinaryType.Executable:
						return ".exe";
					case UEBuildBinaryType.StaticLibrary:
						return ".lib";
					case UEBuildBinaryType.Object:
						return ".o";
					case UEBuildBinaryType.PrecompiledHeader:
						return ".gch";
				}
				return base.GetBinaryExtension(InBinaryType);
			}
			else
			{
				switch (InBinaryType)
				{
					case UEBuildBinaryType.DynamicLinkLibrary:
						return ".js";
					case UEBuildBinaryType.Executable:
						return ".js";
					case UEBuildBinaryType.StaticLibrary:
						return ".bc";
					case UEBuildBinaryType.Object:
						return ".bc";
					case UEBuildBinaryType.PrecompiledHeader:
						return ".gch";
				}

				return base.GetBinaryExtension(InBinaryType);
			}
		}

		/// <summary>
		/// The configuration class for a binary build.
		/// </summary>
		/// <param name="InType"></param>
		/// <param name="InOutputFilePath"></param>
		/// <param name="bInAllowExports"></param>
		/// <param name="bInCreateImportLibrarySeparately"></param>
		/// <param name="bInIsCrossTarget">For most binaries, this is false. If this is a cross-platform binary build for a specific platform (for example XB1 DLL for a windows editor) this will be true.</param>
		/// <param name="InProjectFilePath"></param>
		/// <param name="InModuleNames"></param>
		public UEBuildBinaryConfiguration(
				UEBuildBinaryType InType,
				IEnumerable<FileReference> InOutputFilePaths = null,
				DirectoryReference InIntermediateDirectory = null,
				bool bInAllowExports = false,
				bool bInCreateImportLibrarySeparately = false,
				bool bInIncludeDependentLibrariesInLibrary = false,
				bool bInAllowCompilation = true,
				bool bInHasModuleRules = true,
				bool bInIsCrossTarget = false,
				FileReference InProjectFilePath = null,
				IEnumerable<string> InModuleNames = null
			)
		{
			Type = InType;
			if (InOutputFilePaths != null)
			{
				OutputFilePaths.AddRange(InOutputFilePaths);
			}
			IntermediateDirectory = InIntermediateDirectory;
			bAllowExports = bInAllowExports;
			bCreateImportLibrarySeparately = bInCreateImportLibrarySeparately;
			bIncludeDependentLibrariesInLibrary = bInIncludeDependentLibrariesInLibrary;
			bAllowCompilation = bInAllowCompilation;
			bHasModuleRules = bInHasModuleRules;
			bIsCrossTarget = bInIsCrossTarget;
			ProjectFilePath = InProjectFilePath;
			if (InModuleNames != null)
			{
				ModuleNames.AddRange(InModuleNames);
			}
		}

 /**
  *	Get the extension to use for debug info for the given binary type
  *
  *	@param	InBinaryType		The binary type being built
  *
  *	@return	string				The debug info extension (i.e. 'pdb')
  */
 public override string GetDebugInfoExtension(UEBuildBinaryType InBinaryType)
 {
     return ".pdb";
 }

        /// <summary>
        /// The configuration class for a binary build.
        /// </summary>
        /// <param name="InType"></param>
        /// <param name="InOutputFilePath"></param>
        /// <param name="bInAllowExports"></param>
        /// <param name="bInCreateImportLibrarySeparately"></param>
        /// <param name="bInIsCrossTarget">For most binaries, this is false. If this is a cross-platform binary build for a specific platform (for example XB1 DLL for a windows editor) this will be true.</param>
        /// <param name="InProjectFilePath"></param>
        /// <param name="InModuleNames"></param>
        public UEBuildBinaryConfiguration(
				UEBuildBinaryType InType,
				string InOutputFilePath = null,
				string InIntermediateDirectory = null,
				bool bInAllowExports = false,
				bool bInCreateImportLibrarySeparately = false,
				bool bInIncludeDependentLibrariesInLibrary = false,
				bool bInAllowCompilation = true,
                bool bInIsCrossTarget = false,
                bool bInCompileMonolithic = false,
				UnrealTargetConfiguration InTargetConfiguration = UnrealTargetConfiguration.Development,
				string InTargetName = "",
				string InProjectFilePath = "",
				List<string> InModuleNames = null
			)
        {
            Type = InType;
            OutputFilePath = InOutputFilePath;
            IntermediateDirectory = InIntermediateDirectory;
            bAllowExports = bInAllowExports;
            bCreateImportLibrarySeparately = bInCreateImportLibrarySeparately;
            bIncludeDependentLibrariesInLibrary = bInIncludeDependentLibrariesInLibrary;
            bAllowCompilation = bInAllowCompilation;
            bIsCrossTarget = bInIsCrossTarget;
            bCompileMonolithic = bInCompileMonolithic;
            TargetConfiguration = InTargetConfiguration;
            TargetName = InTargetName;
            ProjectFilePath = InProjectFilePath;
            ModuleNames = InModuleNames;
        }

        /// <summary>
        /// Makes a filename (without path) for a compiled binary (e.g. "Core-Win64-Debug.lib") */
        /// </summary>
        /// <param name="BinaryName">The name of this binary</param>
        /// <param name="Platform">The platform being built for</param>
        /// <param name="Configuration">The configuration being built</param>
        /// <param name="UndecoratedConfiguration">The target configuration which doesn't require a platform and configuration suffix. Development by default.</param>
        /// <param name="BinaryType">Type of binary</param>
        /// <returns>Name of the binary</returns>
        public static string MakeBinaryFileName(string BinaryName, UnrealTargetPlatform Platform, UnrealTargetConfiguration Configuration, UnrealTargetConfiguration UndecoratedConfiguration, UEBuildBinaryType BinaryType)
        {
            StringBuilder Result = new StringBuilder();

            if (Platform == UnrealTargetPlatform.Linux && (BinaryType == UEBuildBinaryType.DynamicLinkLibrary || BinaryType == UEBuildBinaryType.StaticLibrary))
            {
                Result.Append("lib");
            }

            Result.Append(BinaryName);

            if(Configuration != UndecoratedConfiguration)
            {
                Result.AppendFormat("-{0}-{1}", Platform.ToString(), Configuration.ToString());
            }

            IUEBuildPlatform BuildPlatform = UEBuildPlatform.GetBuildPlatform(Platform);
            Result.Append(BuildPlatform.ApplyArchitectureName(""));

            if (BuildConfiguration.bRunUnrealCodeAnalyzer)
            {
                Result.AppendFormat("-{0}.analysis", BuildConfiguration.UCAModuleToAnalyze);
            }
            else
            {
                Result.Append(BuildPlatform.GetBinaryExtension(BinaryType));
            }

            return Result.ToString();
        }

        /// <summary>
        /// Adds a binary for the given module. Does not check whether a binary already exists, or whether a binary should be created for this build configuration.
        /// </summary>
        /// <param name="ModuleName">Name of the binary</param>
        /// <param name="BinaryType">Type of binary to be created</param>
        /// <param name="bAllowCompilation">Whether this binary can be compiled. The function will check whether plugin binaries can be compiled.</param>
        /// <param name="bIsCrossTarget">True if module is for supporting a different target-platform</param>
        /// <returns>The new binary</returns>
        private UEBuildBinaryCPP AddBinaryForModule(string ModuleName, UEBuildBinaryType BinaryType, bool bAllowCompilation, bool bIsCrossTarget)
        {
            // Get the plugin info for this module
            PluginInfo Plugin = FindPluginForModule(ModuleName);

            // Get the root output directory and base name (target name/app name) for this binary
            string BaseOutputDirectory;
            if(Plugin != null)
            {
                BaseOutputDirectory = Path.GetFullPath(Plugin.Directory);
            }
            else if(RulesCompiler.IsGameModule(ModuleName) || !bUseSharedBuildEnvironment)
            {
                BaseOutputDirectory = Path.GetFullPath(ProjectDirectory);
            }
            else
            {
                BaseOutputDirectory = Path.GetFullPath(BuildConfiguration.RelativeEnginePath);
            }

            // Get the configuration that this module will be built in. Engine modules compiled in DebugGame will use Development.
            UnrealTargetConfiguration ModuleConfiguration = Configuration;
            if(Configuration == UnrealTargetConfiguration.DebugGame && !RulesCompiler.IsGameModule(ModuleName))
            {
                ModuleConfiguration = UnrealTargetConfiguration.Development;
            }

            // Get the output and intermediate directories for this module
            string OutputDirectory = Path.Combine(BaseOutputDirectory, "Binaries", Platform.ToString());
             			string IntermediateDirectory = Path.Combine(BaseOutputDirectory, BuildConfiguration.PlatformIntermediateFolder, AppName, ModuleConfiguration.ToString());

            // Append a subdirectory if the module rules specifies one
            ModuleRules ModuleRules;
            if(RulesCompiler.TryCreateModuleRules(ModuleName, TargetInfo, out ModuleRules) && !String.IsNullOrEmpty(ModuleRules.BinariesSubFolder))
            {
                OutputDirectory = Path.Combine(OutputDirectory, ModuleRules.BinariesSubFolder);
                IntermediateDirectory = Path.Combine(IntermediateDirectory, ModuleRules.BinariesSubFolder);
            }

            // Get the output filenames
            string BaseBinaryPath = Path.Combine(OutputDirectory, MakeBinaryFileName(AppName + "-" + ModuleName, Platform, ModuleConfiguration, Rules.UndecoratedConfiguration, BinaryType));
            string[] OutputFilePaths = UEBuildPlatform.GetBuildPlatform(Platform).FinalizeBinaryPaths(BaseBinaryPath);

            // Prepare the configuration object
            UEBuildBinaryConfiguration Config = new UEBuildBinaryConfiguration(BinaryType);
            Config.OutputFilePaths = OutputFilePaths;
            Config.IntermediateDirectory = IntermediateDirectory;
            Config.bHasModuleRules = (ModuleRules != null);
            Config.bAllowExports = (BinaryType == UEBuildBinaryType.DynamicLinkLibrary);
            Config.bAllowCompilation = bAllowCompilation;
            Config.bIsCrossTarget = bIsCrossTarget;
            Config.ModuleNames.Add(ModuleName);

            // Create the new binary
            UEBuildBinaryCPP Binary = new UEBuildBinaryCPP(this, Config);
            AppBinaries.Add(Binary);
            return Binary;
        }