/// <summary> /// Setup the binaries for this target /// </summary> protected override void SetupBinaries() { base.SetupBinaries(); { // Make the editor executable. UEBuildBinaryConfiguration Config = new UEBuildBinaryConfiguration(InType: UEBuildBinaryType.Executable, InOutputFilePaths: OutputPaths, InIntermediateDirectory: EngineIntermediateDirectory, bInCreateImportLibrarySeparately: (ShouldCompileMonolithic() ? false : true), bInAllowExports: !ShouldCompileMonolithic(), InModuleNames: new List<string>() { "Launch" }); if (Platform == UnrealTargetPlatform.Win64 && Configuration != UnrealTargetConfiguration.Shipping) { Config.bBuildAdditionalConsoleApp = true; } AppBinaries.Add(new UEBuildBinaryCPP(this, Config)); } // Add the other modules that we want to compile along with the executable. These aren't necessarily // dependencies to any of the other modules we're building, so we need to opt in to compile them. { // Modules should properly identify the 'extra modules' they need now. // There should be nothing here! } }
/// <summary> /// Setup the binaries for this target /// </summary> protected override void SetupBinaries() { base.SetupBinaries(); { // Make the editor executable. UEBuildBinaryConfiguration Config = new UEBuildBinaryConfiguration(InType: UEBuildBinaryType.Executable, InOutputFilePaths: OutputPaths, InIntermediateDirectory: EngineIntermediateDirectory, bInCreateImportLibrarySeparately: (ShouldCompileMonolithic() ? false : true), bInAllowExports: !ShouldCompileMonolithic(), InModuleNames: new List <string>() { "Launch" }); AppBinaries.Add(new UEBuildBinaryCPP(this, Config)); } // Add the other modules that we want to compile along with the executable. These aren't necessarily // dependencies to any of the other modules we're building, so we need to opt in to compile them. { // Modules should properly identify the 'extra modules' they need now. // There should be nothing here! } // Allow the platform to setup binaries UEBuildPlatform.GetBuildPlatform(Platform).SetupBinaries(this); }
/// <summary> /// Setup the binaries for this target /// </summary> protected override void SetupBinaries() { base.SetupBinaries(); { // Don't write to the Engine intermediate directory for Monolithic builds DirectoryReference IntermediateDirectory = ShouldCompileMonolithic() ? ProjectIntermediateDirectory : EngineIntermediateDirectory; // Make the game executable. UEBuildBinaryConfiguration Config = new UEBuildBinaryConfiguration(InType: UEBuildBinaryType.Executable, InOutputFilePaths: OutputPaths, InIntermediateDirectory: IntermediateDirectory, bInCreateImportLibrarySeparately: (ShouldCompileMonolithic() ? false : true), bInAllowExports: !ShouldCompileMonolithic(), InModuleNames: new List<string>() { "Launch" }); AppBinaries.Add(new UEBuildBinaryCPP(this, Config)); } // Add the other modules that we want to compile along with the executable. These aren't necessarily // dependencies to any of the other modules we're building, so we need to opt in to compile them. { // Modules should properly identify the 'extra modules' they need now. // There should be nothing here! } }
/// <summary> /// Create an instance initialized to the given configuration /// </summary> /// <param name="InConfig">The build binary configuration to initialize the instance to</param> public UEBuildBinaryCPP(UEBuildTarget InTarget, UEBuildBinaryConfiguration InConfig) : base(InTarget, InConfig) { ModuleNames = new HashSet <string>(InConfig.ModuleNames); bCreateImportLibrarySeparately = InConfig.bCreateImportLibrarySeparately; bIncludeDependentLibrariesInLibrary = InConfig.bIncludeDependentLibrariesInLibrary; }
/// <summary> /// Create an instance of the class with the given configuration data /// </summary> /// <param name="InConfig">The build binary configuration to initialize the class with</param> public UEBuildBinary(UEBuildBinaryConfiguration InConfig) { Debug.Assert(InConfig.OutputFilePath != null && InConfig.IntermediateDirectory != null); Config = InConfig; bCreateImportLibrarySeparately = InConfig.bCreateImportLibrarySeparately; bIncludeDependentLibrariesInLibrary = InConfig.bIncludeDependentLibrariesInLibrary; }
/// <summary> /// Create an instance of the class with the given configuration data /// </summary> /// <param name="InConfig">The build binary configuration to initialize the class with</param> public UEBuildBinary(UEBuildTarget InTarget, UEBuildBinaryConfiguration InConfig) { Debug.Assert(InConfig.OutputFilePath != null && InConfig.IntermediateDirectory != null); Target = InTarget; Config = InConfig; }
/// <summary> /// Create an instance initialized to the given configuration /// </summary> /// <param name="InConfig">The build binary configuration to initialize the instance to</param> public UEBuildBinaryCSDLL(UEBuildTarget InTarget, UEBuildBinaryConfiguration InConfig) : base(InTarget, InConfig) { }
/// <summary> /// Create an instance of the class with the given configuration data /// </summary> /// <param name="InConfig">The build binary configuration to initialize the class with</param> public UEBuildBinary( UEBuildTarget InTarget, UEBuildBinaryConfiguration InConfig) { Debug.Assert(InConfig.OutputFilePath != null && InConfig.IntermediateDirectory != null); Target = InTarget; Config = InConfig; }
/// <summary> /// Create an instance initialized to the given configuration /// </summary> /// <param name="InConfig">The build binary configuration to initialize the instance to</param> public UEBuildBinaryCPP( UEBuildTarget InTarget, UEBuildBinaryConfiguration InConfig ) : base(InTarget, InConfig) { ModuleNames = new List<string>(InConfig.ModuleNames); bCreateImportLibrarySeparately = InConfig.bCreateImportLibrarySeparately; bIncludeDependentLibrariesInLibrary = InConfig.bIncludeDependentLibrariesInLibrary; }
/// <summary> /// Create an instance initialized to the given configuration /// </summary> /// <param name="InConfig">The build binary configuration to initialize the instance to</param> public UEBuildBinaryCPP(UEBuildBinaryConfiguration InConfig) : base(InConfig) { bCreateImportLibrarySeparately = InConfig.bCreateImportLibrarySeparately; bIncludeDependentLibrariesInLibrary = InConfig.bIncludeDependentLibrariesInLibrary; }
/// <summary> /// Include the given plugin module in the target. Will be built in the appropriate subfolder under the plugin directory. /// </summary> public List<string> AddPluginModule(PluginInfo Plugin, PluginInfo.PluginModuleInfo Module) { var SpecialRocketLibFilesThatAreBuildProducts = new List<string>(); bool bCompileMonolithic = ShouldCompileMonolithic(); // Get the binary type to build UEBuildBinaryType BinaryType = bCompileMonolithic ? UEBuildBinaryType.StaticLibrary : UEBuildBinaryType.DynamicLinkLibrary; // Get the output path. Don't prefix the app name for Rocket string[] OutputFilePaths; if ((UnrealBuildTool.BuildingRocket() || UnrealBuildTool.RunningRocket()) && bCompileMonolithic) { OutputFilePaths = MakeBinaryPaths(Module.Name, Module.Name, BinaryType, TargetType, Plugin, AppName); if (UnrealBuildTool.BuildingRocket()) { SpecialRocketLibFilesThatAreBuildProducts.AddRange(OutputFilePaths); } } else { OutputFilePaths = MakeBinaryPaths(Module.Name, GetAppName() + "-" + Module.Name, BinaryType, TargetType, Plugin, AppName); } // Try to determine if we have the rules file var ModuleFilename = RulesCompiler.GetModuleFilename(Module.Name); var bHasModuleRules = String.IsNullOrEmpty(ModuleFilename) == false; // Figure out whether we should build it from source var ModuleSourceFolder = bHasModuleRules ? Path.GetDirectoryName(RulesCompiler.GetModuleFilename(Module.Name)) : ModuleFilename; bool bShouldBeBuiltFromSource = bHasModuleRules && Directory.GetFiles(ModuleSourceFolder, "*.cpp", SearchOption.AllDirectories).Length > 0; string PluginIntermediateBuildPath; { if (Plugin.LoadedFrom == PluginInfo.LoadedFromType.Engine) { // Plugin folder is in the engine directory var PluginConfiguration = Configuration == UnrealTargetConfiguration.DebugGame ? UnrealTargetConfiguration.Development : Configuration; PluginIntermediateBuildPath = Path.GetFullPath(Path.Combine(BuildConfiguration.RelativeEnginePath, BuildConfiguration.PlatformIntermediateFolder, AppName, PluginConfiguration.ToString())); } else { // Plugin folder is in the project directory PluginIntermediateBuildPath = Path.GetFullPath(Path.Combine(ProjectDirectory, BuildConfiguration.PlatformIntermediateFolder, GetTargetName(), Configuration.ToString())); } PluginIntermediateBuildPath = Path.Combine(PluginIntermediateBuildPath, "Plugins", ShouldCompileMonolithic() ? "Static" : "Dynamic"); } // Create the binary UEBuildBinaryConfiguration Config = new UEBuildBinaryConfiguration( InType: BinaryType, InOutputFilePaths: OutputFilePaths, InIntermediateDirectory: PluginIntermediateBuildPath, bInAllowExports: true, bInAllowCompilation: bShouldBeBuiltFromSource, bInHasModuleRules: bHasModuleRules, InModuleNames: new List<string> { Module.Name } ); AppBinaries.Add(new UEBuildBinaryCPP(this, Config)); return SpecialRocketLibFilesThatAreBuildProducts; }
public override void RecursivelyProcessUnboundModules(UEBuildTarget Target, ref Dictionary<string, UEBuildBinary> Binaries, UEBuildBinary ExecutableBinary) { // Make sure this module is bound to a binary if( !bIncludedInTarget ) { throw new BuildException( "Module '{0}' should already have been bound to a binary!", Name ); } var AllModuleNames = new List<string>(); AllModuleNames.AddRange( PrivateDependencyModuleNames ); AllModuleNames.AddRange( PublicDependencyModuleNames ); AllModuleNames.AddRange( DynamicallyLoadedModuleNames ); AllModuleNames.AddRange( PlatformSpecificDynamicallyLoadedModuleNames ); foreach( var DependencyName in AllModuleNames ) { var DependencyModule = Target.FindOrCreateModuleByName(DependencyName); // Skip modules that are included with the target (externals) if( !DependencyModule.bIncludedInTarget ) { if( !Binaries.ContainsKey( DependencyModule.Name ) ) { UEBuildBinary BinaryToBindTo; if (Target.ShouldCompileMonolithic()) { // When linking monolithically, any unbound modules will be linked into the main executable BinaryToBindTo = ExecutableBinary; } else { // Is this a Rocket module? bool bIsRocketModule = RulesCompiler.IsRocketProjectModule(DependencyName); // Is this a plugin module? var PluginInfo = Plugins.GetPluginInfoForModule( DependencyName ); string OutputFilePath = Target.MakeBinaryPath(DependencyModule.Name, Target.GetAppName() + "-" + DependencyModule.Name, UEBuildBinaryType.DynamicLinkLibrary, Target.Rules.Type, bIsRocketModule, PluginInfo, ""); // If it's an engine module, output intermediates to the engine intermediates directory. string IntermediateDirectory = Binary.Config.IntermediateDirectory; if (PluginInfo == null && IntermediateDirectory != Target.EngineIntermediateDirectory && Path.GetFullPath(DependencyModule.ModuleDirectory).StartsWith(Path.GetFullPath(BuildConfiguration.RelativeEnginePath))) { IntermediateDirectory = Target.EngineIntermediateDirectory; } // When using modular linkage, unbound modules will be linked into their own DLL files UEBuildBinaryConfiguration Config = new UEBuildBinaryConfiguration( InType: UEBuildBinaryType.DynamicLinkLibrary, InOutputFilePath: OutputFilePath, InIntermediateDirectory: IntermediateDirectory, bInAllowExports: true, InModuleNames: new List<string> { DependencyModule.Name }, InTargetName: Target.GetAppName(), bInIsCrossTarget: PlatformSpecificDynamicallyLoadedModuleNames.Contains(DependencyName) && !DynamicallyLoadedModuleNames.Contains(DependencyName), InTargetConfiguration: Target.Configuration, bInCompileMonolithic: Target.ShouldCompileMonolithic() ); // Fix up the binary path if this is module specifies an alternate output directory Config.OutputFilePath = DependencyModule.FixupOutputPath(Config.OutputFilePath); BinaryToBindTo = new UEBuildBinaryCPP( Target, Config ); } Binaries[ DependencyModule.Name ] = BinaryToBindTo; // Bind this module DependencyModule.Binary = BinaryToBindTo; DependencyModule.bIncludedInTarget = true; // Also add binaries for this module's dependencies DependencyModule.RecursivelyProcessUnboundModules( Target, ref Binaries, ExecutableBinary ); } } if (Target.ShouldCompileMonolithic() == false) { // Check to see if there is a circular relationship between the module and it's referencer if( DependencyModule.Binary != null ) { if( CircularlyReferencedDependentModules.Contains( DependencyName ) ) { DependencyModule.Binary.SetCreateImportLibrarySeparately( true ); } } } } // Also make sure module entries are created for any module that is pulled in as an "include path" module. // These modules are never linked in unless they were referenced as an actual dependency of a different module, // but we still need to keep track of them so that we can find their include paths when setting up our // module's include paths. RecursivelyAddIncludePathModules( Target, bPublicIncludesOnly:false ); }
/// <summary> /// Create an instance initialized to the given configuration /// </summary> /// <param name="InConfig">The build binary configuration to initialize the instance to</param> public UEApkDummyBinary(UEBuildTarget InTarget, UEBuildBinaryConfiguration InConfig) : base(InTarget, InConfig) { }
public override void SetupBinaries(UEBuildTarget InBuildTarget) { // dangerously fast mode doesn't generate stub files if (!IOSToolChain.bUseDangerouslyFastMode) { List<UEBuildBinary> NewBinaries = new List<UEBuildBinary>(); // add the .apk to the binaries foreach (var Binary in InBuildTarget.AppBinaries) { // make a binary that just points to the .stub of this executable UEBuildBinaryConfiguration NewConfig = new UEBuildBinaryConfiguration( InType: Binary.Config.Type, InOutputFilePath: Path.ChangeExtension(Binary.Config.OutputFilePath, ".apk"), InIntermediateDirectory: Binary.Config.IntermediateDirectory, bInCreateImportLibrarySeparately: Binary.Config.bCreateImportLibrarySeparately, bInAllowExports: Binary.Config.bAllowExports, InModuleNames: Binary.Config.ModuleNames); NewBinaries.Add(new UEStubDummyBinary(InBuildTarget, NewConfig)); } InBuildTarget.AppBinaries.AddRange(NewBinaries); } }
/// <summary> /// Create an instance initialized to the given configuration /// </summary> /// <param name="InConfig">The build binary configuration to initialize the instance to</param> public UEBuildBinaryCPP(UEBuildTarget InTarget, UEBuildBinaryConfiguration InConfig) : base(InTarget, InConfig) { bCreateImportLibrarySeparately = InConfig.bCreateImportLibrarySeparately; bIncludeDependentLibrariesInLibrary = InConfig.bIncludeDependentLibrariesInLibrary; }
/// <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; }
/// <summary> /// Create an instance initialized to the given configuration /// </summary> /// <param name="InConfig">The build binary configuration to initialize the instance to</param> public UEBuildBinaryCSDLL(UEBuildBinaryConfiguration InConfig) : base(InConfig) { }
/// When building a target, this is called to add any additional modules that should be compiled along /// with the main target. If you override this in a derived class, remember to call the base implementation! protected virtual void AddExtraModules() { // Add extra modules that will either link into the main binary (monolithic), or be linked into separate DLL files (modular) foreach (var ModuleName in ExtraModuleNames) { if (ShouldCompileMonolithic()) { // Add this module to the executable's list of included modules var ExecutableBinary = AppBinaries[0]; ExecutableBinary.AddModule(ModuleName); } else { // Create a DLL binary for this module string[] OutputFilePaths = MakeBinaryPaths(ModuleName, GetAppName() + "-" + ModuleName, UEBuildBinaryType.DynamicLinkLibrary, TargetType, null, AppName); UEBuildBinaryConfiguration Config = new UEBuildBinaryConfiguration( InType: UEBuildBinaryType.DynamicLinkLibrary, InOutputFilePaths: OutputFilePaths, InIntermediateDirectory: RulesCompiler.IsGameModule(ModuleName) ? ProjectIntermediateDirectory : EngineIntermediateDirectory, bInAllowExports: true, InModuleNames: new List<string> { ModuleName } ); // Tell the target about this new binary AppBinaries.Add(new UEBuildBinaryCPP(this, Config)); } } }