La herramienta UE Build Tool (UBT) permite compilar varios tipos de destinos:
Juego: un juego independiente que requiere datos procesados para ejecutarse.
Cliente: igual que Juego, pero sin código de servidor. Útil para juegos en red.
Servidor: igual que Juego, pero sin código de cliente. Útil para servidores dedicados en juegos en red.
Editor: un destino que amplía Unreal Editor.
Programa: un programa utilitario independiente construido sobre Unreal Engine.
Los destinos se declaran a través de archivos fuente de C# con la extensión .target.cs y se almacenan en el directorio raíz de tu proyecto. Cada archivo .target.cs declara una clase derivada de la clase base TargetRules y establece propiedades que controlan cómo debe compilarse a partir de su constructor. Cuando se le pida que cree un destino, la herramienta UE Build Tool compilará tu archivo .target.cs y construirá la clase que contiene para determinar sus ajustes.
El nombre de la clase debe coincidir con el nombre del archivo en el que se declara seguido de *Target* (por ejemplo, MyProject.target.cs define la clase MyProjectTarget).
La estructura típica de un archivo de destino es la siguiente:
using UnrealBuildTool;
using System.Collections.Generic;
public class MyProjectTarget : TargetRules
{
public MyProjectTarget(TargetInfo Target) : base(Target)
{
Type = TargetType.Game;
// Other properties go here
}
}Propiedades de solo lectura
$ OriginalName (String): devuelve el nombre de destino original sin anulaciones ni adornos.
$ IsTestTarget (Boolean): determina si se trata de un destino de pruebas de bajo nivel.
$ ExplicitTestsTarget (Boolean): indica si se trata de un destino de prueba definido explícitamente. Los destinos de prueba definidos explícitamente siempre se heredan de TestTargetRules y definen sus propias pruebas. Los destinos de prueba implícitos se crean a partir de destinos existentes al compilar con -Mode=Test e incluyen pruebas de todas las dependencias.
$ WithLowLevelTests (Boolean): controla el valor de WITH_LOW_LEVEL_TESTS, que dicta si se compilan o no las pruebas de bajo nivel específicas del módulo.
$ Architecture (UnrealArch): obtiene la arquitectura en el caso normal en el que solo hay una arquitectura en Architectures (se producirá una excepción si se ha especificado más que una arquitectura).
$ bIWYU (Boolean): activa por defecto la opción «incluir lo que uses» para los módulos de este destino. Cambia el modo de PCH predeterminado para cualquier módulo de este proyecto a PCHUsageMode.UseExplicitOrSharedPCHs.
$ DisableDebugInfoModules (HashSet<String>): determina qué módulos deberían tener la información de depuración desactivada.
$ DisableDebugInfoPlugins (HashSet<String>): determina qué complementos deberían tener la información de depuración desactivada.
$ DebugInfoLineTablesOnlyModules (HashSet<String>): determina qué módulos deben emitir tablas de números de línea en lugar de información de depuración completa para los compiladores que lo admitan. Anula DisableDebugInfoModules.
$ DebugInfoLineTablesOnlyPlugins (HashSet<String>): determina qué complementos deben emitir tablas de números de línea en lugar de información de depuración completa para los compiladores que lo admitan. Anula DisableDebugInfoPlugins.
$ MergePlugins (List<String>): experimental. Lista de complementos (y sus dependencias) para fusionar en bibliotecas independientes. Requiere que bMergeModules esté activado.
$ MergePluginsShared (Dictionary<String, HashSet<String>>): experimental. Lista de complementos fusionados para mover dependencias comunes a una biblioteca compartida. Requiere MergePlugins. Se puede encadenar.
$ MergePluginsLaunch (List<String>): experimental. Lista de complementos fusionados que se moverán al ejecutable principal. Requiere MergePlugins. «Engine» para todos los módulos de motor compartidos y «Common» para los módulos de proyecto compartidos.
$ GlobalDefinitions (List<String>): macros para definir globalmente en todo el destino.
$ ProjectDefinitions (List<String>): macros que definir en todas las macros del proyecto.
$ ExtraModuleNames (List<String>): lista de módulos adicionales que se compilarán en el destino.
$ ManifestFileNames (List<FileReference>): ruta a un manifiesto para la salida de este destino.
$ DependencyListFileNames (List<FileReference>): ruta a una lista de dependencias para este destino al precompilar.
$ PreBuildTargets (List<TargetInfo>): especifica una lista de destinos que deberían compilarse antes de crear este destino.
$ PreBuildSteps (List<String>): especifica una lista de pasos que deberían ejecutarse antes de compilar este destino en el contexto del shell de la plataforma. Las siguientes variables se expandirán antes de la ejecución: $(EngineDir), $(ProjectDir), $(TargetName), $(TargetPlatform), $(TargetConfiguration), $(TargetType), $(ProjectFile).
$ PostBuildSteps (List<String>): especifica una lista de pasos que deberían ejecutarse después de compilar este destino en el contexto del shell de la plataforma. Las siguientes variables se expandirán antes de la ejecución: $(EngineDir), $(ProjectDir), $(TargetName), $(TargetPlatform), $(TargetConfiguration), $(TargetType), $(ProjectFile).
$ AdditionalBuildProducts (List<String>): especifica los productos de compilación adicionales producidos como parte de este destino.
$ HostPlatform (UnrealTargetPlatform): obtiene la plataforma host en la que se está compilando.
$ bGenerateProjectFiles (Boolean): expone el indicador bGenerateProjectFiles a los destinos para que podamos modificar el comportamiento según sea necesario para una mejor inteligencia.
$ bShouldTargetRulesTogglePlugins (Boolean): indica si deben usarse reglas de destino para activar o desactivar complementos de forma explícita. Por lo general, no se necesita para la generación de proyectos a menos que los archivos del proyecto indiquen si los complementos a los que se hace referencia deben compilarse o no.
$ bIsEngineInstalled (Boolean): expone un ajuste para instalar o no el motor.
Propiedades de lectura/escritura
$ BuildPlugins (List<String>): complementos adicionales que se compilan para este tipo de destino pero que no se activan.
$ AdditionalPlugins (List<String>): una lista de complementos adicionales que deben incluirse en este destino. Esto permite referencias a módulos de complementos no opcionales que no se pueden desactivar, y permite compilar para módulos específicos en destinos de programa que no encajan en las categorías de ModuleHostType.
$ EnablePlugins (List<String>): complementos adicionales que deberían incluirse para este destino.
$ DisablePlugins (List<String>): Lista de complementos que se desactivan para este destino. Ten en cuenta que es posible que el archivo del proyecto siga haciendo referencia a ellos, por lo que deberían marcarse como opcionales para evitar que se produzcan errores en el tiempo de ejecución.
$ OptionalPlugins (List<String>): complementos adicionales que deberían incluirse para este destino (si se encuentran).
$ InternalPluginDependencies (List<String>): una lista de nombres de complementos que pueden existir como dependencias sin estar definidos en el descriptor `uplugin`.
$ DisableMergingModuleAndGeneratedFilesInUnityFiles (String[]): lista de módulos que desactiva la fusión del módulo y los archivos cpp generados en los mismos archivos de Unity.
$ bShowIncludes (Boolean): muestra los archivos incluidos en cada archivo de origen.
$ DisableUnityBuildForModules (String[]): lista de módulos para los que se desactivarán las compilaciones de Unity.
$ EnableOptimizeCodeForModules (String[]): lista de módulos para los que se pueden activar las optimizaciones.
$ DisableOptimizeCodeForModules (String[]): lista de módulos para los que se desactivarán las optimizaciones.
$ OptimizeForSizeModules (String[]): lista de módulos cuyo tamaño optimizar. Esto permite que el objetivo anule el nivel de optimización del módulo. Ten en cuenta que esto puede desactivar el uso de la PCH si no se proporciona una PCH privada.
$ OptimizeForSizeAndSpeedModules (String[]): lista de módulos cuyo tamaño y velocidad optimizar. Esto permite que el objetivo anule el nivel de optimización del módulo. Ten en cuenta que esto puede desactivar el uso de la PCH si no se proporciona una PCH privada.
$ OptedInModulePlatforms (UnrealTargetPlatform[]): si esto no es nulo, las plataformas que NO estén en la lista no podrán tener módulos en sus directorios.
$ Name (String): el nombre de este destino.
$ Logger (ILogger): registrador para la salida relacionada con este destino. Se establece antes de que se ejecute el constructor
$ AdditionalData (Object): objeto genérico que acepta valores nulos para que un usuario pueda establecer datos adicionales en una TargetRule de un proyecto y acceder a una ModuleRule de un proyecto sin necesidad de añadir nuevas propiedades después del lanzamiento. Por ejemplo:
* in .Target.cs: AdditionalData = "data";
* in .Build.cs: if ((Target.AdditionalData as string) == "data") { ... }
$ Platform (UnrealTargetPlatform): plataforma para la que se está compilando este destino.
$ Configuration (UnrealTargetConfiguration): la configuración que se está compilando.
$ Architectures (UnrealArchitectures): la arquitectura para la que se está compilando el destino (o una cadena vacía por defecto).
$ IntermediateEnvironment (UnrealIntermediateEnvironment): entorno de intermedios. Determina si los intermedios terminan en una carpeta diferente a la normal.
$ ProjectFile (FileReference): ruta al archivo del proyecto que contiene este destino.
$ Version (ReadOnlyBuildVersion): la versión de compilación actual.
$ Type (TargetType): el tipo de destino.
$ DefaultBuildSettings (BuildSettingsVersion): especifica la versión del motor con la que mantener los ajustes de compilación predeterminados compatibles con versiones anteriores (p. ej., DefaultSettingsVersion.Release_4_23, DefaultSettingsVersion.Release_4_24). Especifica DefaultSettingsVersion.Latest para usar siempre los valores predeterminados para la versión actual del motor (a riesgo de introducir errores de compilación al actualizar).
$ ForcedIncludeOrder (Nullable<EngineIncludeOrderVersion>): fuerza el orden de inclusión a una versión específica. Anula cualquier regla de destino o de módulo.
$ IncludeOrderVersion (EngineIncludeOrderVersion): qué versión del orden de inclusión usar al compilar este destino. Se puede anular con -ForceIncludeOrder en la línea de comandos. ModuleRules.IncludeOrderVersion tiene precedencia.
$ OutputFile (String): ruta al archivo de salida para el ejecutable principal, relativa al motor o al directorio del proyecto. Este ajuste solo suele ser útil para programas que no son de UE, ya que el motor usa rutas relativas al archivo ejecutable para buscar otras carpetas conocidas (p. ej., Content).
$ bUsesSteam (Boolean): indica si el destino usa Steam.
$ bUsesCEF3 (Boolean): indica si el destino usa CEF3.
$ bUsesSlate (Boolean): determina si el proyecto usará la interfaz de usuario visual de Slate (a diferencia de las ventanas o los mensajes de bajo nivel, que siempre están disponibles).
$ bUseStaticCRT (Boolean): fuerza la vinculación con el CRT estático. Esto no es del todo compatible con el motor debido a la necesidad de compartir las implementaciones del asignador (por ejemplo) y de que las bibliotecas de TPS sean coherentes entre sí, pero pueden usarse para programas de utilidades.
$ bDebugBuildsActuallyUseDebugCRT (Boolean): activa el tiempo de ejecución C++ (CRT) de depuración para compilaciones de depuración. De forma predeterminada, siempre usamos el tiempo de ejecución de lanzamiento, ya que la versión de depuración no resulta especialmente útil a la hora de depurar proyectos de Unreal Engine, y el enlace con las bibliotecas de CRT de depuración obliga a que las dependencias de bibliotecas de terceros también se compilen con la CRT de depuración (y se suele ralentizar). A menudo puede ser un inconveniente exigir una copia por separado de las versiones de depuración de las bibliotecas estáticas de terceros solo para poder depurar el código del programa.
$ bLegalToDistributeBinary (Boolean): determina si la salida de este destino puede distribuirse públicamente, incluso si tiene dependencias en módulos que están en carpetas con restricciones especiales (p. ej., CarefullyRedist, NotForLicensees, NoRedist).
$ UndecoratedConfiguration (UnrealTargetConfiguration): especifica la configuración cuyos binarios no requieren un sufijo `-Platform-Configuration`.
$ DecoratedSeparator (String): especifica el carácter separador para los nombres de archivo binarios.
$ bAllowHotReload (Boolean): determina si este destino admite recarga dinámica.
$ bBuildAllModules (Booleano): compila todos los módulos válidos para este tipo de destino. Se usa para CIS y para compilaciones de motor instaladas.
$ VSTestRunSettingsFile (FileReference): establece que haga referencia a un archivo de ajustes de ejecución de VSTest a partir de proyectos generados.
$ bRuntimeDependenciesComeFromBuildPlugins (Boolean): si está activado, se usará la lista BuildPlugins para propagar RuntimeDependencies, en lugar de EnablePlugins.
$ bAllowEnginePluginsEnabledByDefault (Boolean): si está desactivado, suprime la carga de complementos del motor activados por defecto que no estén activados explícitamente por el proyecto o los archivos de destino.
$ DisablePluginsConflictWarningLevel (WarningLevel): cómo tratar los conflictos cuando un complemento desactivado está siendo activado por otro complemento que hace referencia a él.
$ PakSigningKeysFile (String): ruta al conjunto de claves de firma de pak para incrustar en el archivo ejecutable.
$ SolutionDirectory (String): permite que un destino de programa especifique su propia ruta de carpeta de soluciones.
$ bGenerateProgramProject (Boolean): hace que un destino sea tratado como un programa a la hora de generar archivos de proyecto.
$ bExplicitTargetForType (Boolean): si está activado, GetTargetNameByType no tendrá en cuenta a este destino y eliminará la ambigüedad de -TargetType=X.
$ bBuildInSolutionByDefault (Nullable<Boolean>): determina si el destino debería incluirse en la configuración predeterminada de compilación de la solución. Si se desactiva, se omitirá la compilación cuando se ejecute en el IDE.
$ bShouldCompileAsDLL (Boolean): determina si este destino debería compilarse como archivo DLL. Requiere que LinkType esté establecido como TargetLinkType.Monolithic.
$ CustomConfig (String): subdirectorio adicional desde el que cargar archivos de configuración para crear múltiples tipos de compilaciones con la misma plataforma. Se integrará en el archivo ejecutable del juego como CUSTOM_CONFIG y se usará al preparar para filtrar archivos y ajustes.
$ ExeBinariesSubFolder (String): subcarpeta donde colocar los archivos ejecutables en relación con la ubicación predeterminada.
$ GeneratedCodeVersion (EGeneratedCodeVersion): permite que el módulo de destino anule la versión de generación del código UHT.
$ bEnableMeshEditor (Boolean): activa o desactiva el editor de mallas.
$ bUseVerseBPVM (Boolean): determina si se debe usar la BPVM para ejecutar Verse.
$ bUseAutoRTFMCompiler (Boolean): determina si se debe usar el compilador AutoRTFM Clang.
$ bForceNoAutoRTFMCompiler (Boolean): determina si se debe forzar la desactivación del compilador AutoRTFM Clang.
$ bUseAutoRTFMVerifier (Boolean): determina si se activa o no la emisión de metadatos de verificación de AutoRTFM.
$ bCompileChaos (Boolean): determina si se debe compilar el complemento de física Chaos.
$ bUseChaos (Boolean): determina si se debe usar o no la interfaz de física de Chaos. Esto anula los indicadores de Physx para desactivar APEX y NvCloth.
$ bUseChaosChecked (Boolean): determina si se debe compilar con las características de Chaos marcadas para la depuración.
$ bUseChaosMemoryTracking (Boolean): determina si se debe compilar con las funciones de seguimiento de la memoria de Chaos.
$ bCompileChaosVisualDebuggerSupport (Boolean): determina si se deben compilar las funciones de soporte de Chaos Visual Debugger (CVD) para registrar el estado de la simulación de física.
$ bCustomSceneQueryStructure (Boolean): determina si UE acelera las consultas de escena. Se sigue creando la estructura de consulta de la escena Physx, pero no la usaremos.
$ bCompilePhysX (Boolean): determina si se debe incluir o no soporte para PhysX.
$ bCompileAPEX (Boolean): determina si se debe incluir o no el soporte con PhysX APEX.
$ bCompileNvCloth (Boolean): determina si se debe incluir o no NvCloth.
$ bCompileICU (Boolean): determina si se debe incluir o no soporte con ICU Unicode/i18n en Core.
$ bCompileCEF3 (Boolean): determina si se debe compilar con soporte para con CEF3.
$ bCompileISPC (Boolean): determina si se debe compilar usando ISPC.
$ bCompileIntelMetricsDiscovery (Boolean): determina si se debe compilar IntelMetricsDiscovery.
$ bCompilePython (Boolean): determina si se debe compilar con soporte para Python.
$ bUseGameplayDebugger (Boolean): determina si compilar con WITH_GAMEPLAY_DEBUGGER activado con todas las categorías predeterminadas del depurador de jugabilidad del motor.
$ bUseGameplayDebuggerCore (Boolean): se activa cuando bUseGameplayDebugger está desactivado pero las partes principales de GameplayDebugger son necesarias.
$ bCompileIoStoreOnDemand (Boolean): determina si se debe usar o no el almacenamiento de E/S a la carta.
$ bUseIris (Boolean): determina si se debe usar o no Iris.
$ bTrackRHIResourceInfoForTest (Boolean): determina si se debe hacer un seguimiento del propietario (nombre del recurso) del recurso de RHI para la configuración de prueba. Útil para los comandos ListShaderMaps y ListShaderLibraries.
$ bBuildEditor (Boolean): indica si estamos compilando o no el código del editor. bCompileAgainstEditor es preferible, ya que es más explícito.
$ bBuildRequiresCookedData (Boolean): determina si se debe compilar código relacionado con los recursos de construcción. Por lo general, las consolas no pueden compilar recursos. Las plataformas de escritorio sí suelen poder.
$ bBuildWithEditorOnlyData (Boolean): determina si se debe compilar WITH_EDITORONLY_DATA desactivado. Solo Windows usará esto, otras plataformas fuerzan su desactivación.
$ bBuildDeveloperTools (Boolean): determina si se deben compilar las herramientas de desarrolladores.
$ bBuildTargetDeveloperTools (Boolean): determina si se deben compilar las herramientas de desarrolladores para las plataformas de destino o los dispositivos conectados (por defecto, bBuildDeveloperTools).
$ bForceBuildTargetPlatforms (Boolean): determina si se debe forzar la compilación de los módulos de las plataformas de destino, incluso si no se compilarían normalmente.
$ bForceBuildShaderFormats (Boolean): determina si se debe forzar la compilación de módulos de formato de sombreador, incluso si no se compilarían normalmente.
$ bNeedsExtraShaderFormatsOverride (Nullable<Boolean>): anula la inclusión de formatos de sombreador adicionales.
$ bNeedsExtraShaderFormats (Boolean): determina si deberíamos incluir formatos adicionales de sombreador. Por defecto, solo está activado para los destinos del programa y del editor.
$ bCompileCustomSQLitePlatform (Boolean): determina si debemos compilar SQLite usando la plataforma personalizada «Unreal» (activado) o usando la plataforma nativa (desactivado).
$ bUseCacheFreedOSAllocs (Boolean): determina si se utilizarán asignaciones del SO liberadas en la caché con MallocBinned.
$ bCompileAgainstEngine (Boolean): se activa para todas las compilaciones que incluyan el proyecto del motor. Solo se desactiva al compilar apps independientes que solo se vinculan con Core.
$ bCompileAgainstCoreUObject (Boolean): se activa para todas las compilaciones que incluyan el proyecto CoreUObject. Solo se desactiva al compilar apps independientes que solo se vinculan con Core.
$ bCompileAgainstApplicationCore (Boolean): se activa para compilaciones que necesiten inicializar el módulo ApplicationCore. Las utilidades de la línea de comandos normalmente no necesitan esto.
$ bEnableTrace (Boolean): se activa para compilaciones que quieran usar el módulo de trazado para la generación de perfiles y diagnósticos.
$ bForceEnableTrace (Boolean): fuerza la activación del trazado. Se usa para permitir que los programas de prueba verifiquen que el trazado funciona según lo previsto.
$ bCompileAgainstEditor (Boolean): se activa para compilaciones de editor (TargetType.Editor). Puede anularse para programas (TargetType.programa) que necesiten compilarse con el código del editor. No disponible para otros tipos de destino. Principalmente, impulsa el valor de WITH_EDITOR.
$ bCompileRecast (Boolean): determina si se debe compilar la generación de la NavMesh Recast.
$ bCompileNavmeshSegmentLinks (Boolean): determina si se debe compilar con enlaces de segmento de la NavMesh.
$ bCompileNavmeshClusterLinks (Boolean): determina si se debe compilar con enlaces de clúster de la NavMesh.
$ bCompileSpeedTree (Boolean): determina si debemos compilar para que sea compatible con SpeedTree o no.
$ bForceEnableExceptions (Boolean): activa excepciones para todos los módulos.
$ bUseInlining (Boolean): activa la integración en línea en todos los módulos.
$ bForceEnableObjCExceptions (Boolean): activa las excepciones para todos los módulos.
$ bForceEnableRTTI (Boolean): activa RTTI para todos los módulos.
$ bEnablePrivateBuildInformation (Boolean): activa BuildSettings para que contenga información privada sobre la compilación. Como el nombre de máquina, el nombre de usuario y el nombre de dominio del usuario (expuestos en BuildSettings.h).
$ bEnablePIE (Boolean): activa los archivos ejecutables independientes de la posición (PIE). Tiene un coste adicional.
$ bEnableStackProtection (Boolean): activa la protección de pila. Tiene un coste adicional.
$ bWithClientCode (Boolean): compila código exclusivo del cliente.
$ bWithServerCode (Boolean): compila código exclusivo del servidor.
$ bFNameOutlineNumber (Boolean): compila con FName y almacena la parte numérica en la tabla de nombres. Ahorra memoria cuando la mayoría de los nombres no están numerados y los que sí lo están tienen varias referencias. El juego y el motor deben garantizar la reutilización de los nombres numerados de forma similar a las cadenas de nombres para evitar pérdidas de memoria.
$ bWithPushModel (Boolean): cuando se activa, se compilará el soporte para Push Model Networking. Esto puede ayudar a reducir la sobrecarga de la CPU de las redes, a coste de más memoria. Siempre activado en las compilaciones del editor.
$ bCompileWithStatsWithoutEngine (Boolean): determina si se debe incluir o no soporte de estadísticas incluso sin el motor.
$ bCompileWithPluginSupport (Boolean): determina si se debe incluir o no soporte para complementos.
$ bIncludePluginsForTargetPlatforms (Boolean): determina si se permiten complementos compatibles con todas las plataformas de destino.
$ bCompileWithAccessibilitySupport (Boolean): determina si se debe permitir o no el código de accesibilidad tanto en Slate como en la capa del SO.
$ bWithPerfCounters (Boolean): determina si incluye o no soporte para PerfCounters.
$ bWithLiveCoding (Boolean): determina si se habilita el soporte para código en tiempo real.
$ bUseDebugLiveCodingConsole (Boolean): determina si se habilita el soporte para código en tiempo real.
$ bWithDirectXMath (Boolean): determina si se activa o no la compatibilidad con DirectX Math. LWC_TODO: Ya no es compatible. Hay que eliminarlo.
$ bWithFixedTimeStepSupport (Boolean): determina si se activa o no la compatibilidad con FixedTimeStep en el motor.
$ bUseLoggingInShipping (Boolean): determina si se debe activar o no el registro para versiones de prueba/envío.
$ bUseConsoleInShipping (Boolean): determina si se activa o no la consola para las compilaciones de envío.
$ bLoggingToMemoryEnabled (Boolean): determina si se debe activar o no el registro en memoria para las versiones de prueba/envío.
$ bUseLauncherChecks (Boolean): determina si se debe comprobar que el proceso se ha iniciado a través de un iniciador externo.
$ bUseChecksInShipping (Boolean): determina si se deben activar o no las comprobaciones (afirmaciones) para las versiones de prueba/envío.
$ bAllowProfileGPUInTest (Boolean): determina si se deben activar o no los marcadores de GPU para las compilaciones de prueba.
$ bAllowProfileGPUnShipping (Boolean): determina si se deben activar o no los marcadores de GPU para las compilaciones de envío.
$ bTCHARIsUTF8 (Boolean): determina si se debe activar o no el modo UTF-8, asignando TCHAR a UTF8CHAR.
$ bUseEstimatedUtcNow (Boolean): determina si se usa el valor de EstimatedUtcNow o PlatformUtcNow. EstimatedUtcNow es adecuado en los casos en los que PlatformUtcNow puede ser lento.
$ bCompileFreeType (Boolean): se activa si necesitamos compatibilidad con FreeType.
$ bUseExecCommandsInShipping (Boolean): determina si se activan o no los comandos de permiso de ejecución para compilaciones de envío.
$ bCompileForSize (Boolean): se activa si queremos favorecer la optimización de tamaño frente a la velocidad.
$ OptimizationLevel (OptimizationMode): permite ajustar el nivel de optimizaciones para la velocidad y/o tamaño del código.
$ FPSemantics (FPSemanticsMode): permite establecer la semántica de los FP.
$ bForceCompileDevelopmentAutomationTests (Boolean): determina si se deben compilar las pruebas de automatización de desarrollo.
$ bForceCompilePerformanceAutomationTests (Boolean): determina si se deben compilar las pruebas de automatización de rendimiento.
$ bForceDisableAutomationTests (Boolean): determina si se deben anular los valores predeterminados para las pruebas automatizadas (configuraciones de depuración/desarrollo).
$ bEventDrivenLoader (Boolean): si está activado, se usará el cargador orientado a eventos en las versiones compiladas. @todoio Hay que reemplazar esto por una solución en tiempo de ejecución después de la refactorizar de carga asíncrona.
$ NativePointerMemberBehaviorOverride (Nullable<PointerMemberBehavior>): se usa para anular el comportamiento que controla si las clases UCLASS y USTRUCT pueden tener miembros con punteros nativos. Si no se permite, será un error de UHT y debería sustituirse por miembros TObjectPtr.
$ bUseXGEController (Boolean): determina si los módulos y el trabajador del controlador XGE se incluyen en la compilación del motor. Se requieren en la compilación de sombreadores que se distribuye mediante la interfaz XGE.
$ bIncludeHeaders (Boolean): añade archivos de encabezado de los módulos incluidos a la compilación.
$ bHeadersOnly (Boolean): cuando se usa con -IncludeHeaders, solo se compilan los archivos de encabezado.
$ bEnforceIWYU (Boolean): aplica las reglas «incluir lo que uses»; advierte del uso de encabezados monolíticos (Engine.h, UnrealEd.h, etc.) y comprueba que los archivos fuente incluyan primero su encabezado correspondiente.
$ bWarnAboutMonolithicHeadersIncluded (Boolean): emite una advertencia cuando se incluye un encabezado monolítico antiguo al compilar este destino.
$ bHasExports (Boolean): determina si el archivo ejecutable final exportará símbolos.
$ bPrecompile (Boolean): crea bibliotecas estáticas para todos los módulos del motor como intermediarios para este destino.
$ bEnableOSX109Support (Boolean): determina si deberíamos compilar con soporte para OS X 10.9 Mavericks. Se usa para algunas herramientas que necesitamos para ser compatibles con esta versión de OS X.
$ bIsBuildingConsoleApplication (Boolean): está activado si se trata de una aplicación de consola en desarrollo.
$ bBuildAdditionalConsoleApp (Boolean): si está activado, crea una aplicación de consola adicional. Es una solución para Windows, donde no es posible heredar de forma condicional la ventana de la consola principal en función de cómo se invoque la aplicación; es preciso que vincular el mismo ejecutable con un ajuste de subsistema distinto.
$ bBuildConsoleAppOnly (Boolean): si está activado, solo crea una aplicación de consola adicional. Anula bBuildAdditionalConsoleApp.
$ bDisableSymbolCache (Boolean): está activado si no se deberían crear los símbolos de depuración que se almacenan en caché para algunas plataformas.
$ bUseUnityBuild (Boolean): determina si se unifica el código C++ en archivos más grandes para compilar más rápido.
$ bForceUnityBuild (Boolean): determina si se fuerza que los archivos fuente de C++ se combinen en archivos más grandes para una compilación más rápida.
$ bMergeModuleAndGeneratedUnityFiles (Boolean): determina si se deben fusionar los archivos de Unity generados y del módulo para acelerar la compilación.
$ bUseAdaptiveUnityBuild (Boolean): usa una heurística para determinar qué archivos se están iterando actualmente y los excluye de los blobs en Unity, lo que produce tiempos de compilación incrementales más rápidos. La implementación actual usa el indicador de solo lectura para distinguir el conjunto de trabajo, puesto que el sistema de control de versiones añadirá el permiso de escritura a los archivos si se están modificando. Se activa en Perforce, pero no en Git.
$ bAdaptiveUnityDisablesOptimizations (Boolean): desactiva la optimización de los archivos que están en el conjunto de trabajo adaptable fuera de Unity.
$ bAdaptiveUnityDisablesPCH (Boolean): desactiva los PCH forzados de los archivos que están en el conjunto de trabajo adaptable fuera de Unity.
$ bAdaptiveUnityDisablesProjectPCHForProjectPrivate (Nullable<Boolean>): almacenamiento auxiliar para bAdaptiveUnityDisablesProjectPCH.
$ bAdaptiveUnityDisablesPCHForProject (Boolean): indica si se deben desactivar los PCH forzados de los archivos fuente del proyecto en el conjunto de trabajo adaptable fuera de Unity. Por defecto es bAdaptiveUnityDisablesPCH.
$ bAdaptiveUnityCreatesDedicatedPCH (Boolean): crea una PCH dedicada para cada archivo de origen del conjunto de trabajo, lo que permite una iteración más rápida en los cambios que solo afectan a CPP.
$ bAdaptiveUnityEnablesEditAndContinue (Boolean): crea una PCH dedicada para cada archivo de origen del conjunto de trabajo, lo que permite una iteración más rápida en los cambios que solo afectan a CPP.
$ bAdaptiveUnityCompilesHeaderFiles (Boolean): crea un archivo de origen dedicado para cada archivo de encabezado del conjunto de trabajo para detectar las inclusiones que faltan en los archivos de encabezado.
$MinGameModuleSourceFilesForUnityBuild (Int32): número de archivos de origen en un módulo de juego antes de que se active la compilación de Unity para ese módulo. Esto permite que los módulos de juego pequeños tengan tiempos de compilación iterativos más rápidos con archivos individuales, a expensas de que las compilaciones completas lleven más tiempo. Este ajuste puede anularse con la opción bFasterWithoutUnity en el archivo Build.cs de un módulo.
$ DefaultWarningLevel (WarningLevel): tratamiento predeterminado de las advertencias sin categorizar.
$ bRequireObjectPtrForAddReferencedObjects (Boolean): requiere TObjectPtr para las API de FReferenceCollector. (Obligatorio para mantener la compatibilidad con GC incremental).
$ bValidateFormatStrings (Boolean): emite errores de compilación para cadenas con formato UE_LOG incorrecto.
$ DeprecationWarningLevel (WarningLevel): nivel para informar de las advertencias de desactivación como errores.
$ ShadowVariableWarningLevel (WarningLevel): hace que las advertencias de las variables de sombras se traten como errores en las plataformas compatibles.
$ bWarningsAsErrors (Boolean): determina si se habilitan todas las advertencias como errores. UE ya activa la mayoría de las advertencias como errores, pero desactiva algunas (como las advertencias de desactualización).
$ UnsafeTypeCastWarningLevel (WarningLevel): indica qué nivel de advertencia/error otorgar a las conversiones de tipos que no sean seguras en plataformas compatibles (p. ej., double-> Float o int64->int32).
$ bUndefinedIdentifierErrors (Boolean): obliga a que el uso de identificadores indefinidos en expresiones condicionales se considere un error.
$ UndefinedIdentifierWarningLevel (WarningLevel): indica qué nivel de advertencia/error otorgar a los identificadores indefinidos en las expresiones condicionales.
$ PCHPerformanceIssueWarningLevel (WarninLevel): indica qué nivel de advertencia/error otorgar a los posibles problemas de rendimiento de PCH.
$ ModuleIncludePathWarningLevel (WarningLevel): cómo tratar los mensajes generales de validación de las rutas de inclusión del módulo.
$ ModuleIncludePrivateWarningLevel (WarningLevel): cómo tratar los mensajes de validación de las rutas de inclusión de módulos privados, donde un módulo añade una ruta de inclusión que expone encabezados privados.
$ ModuleIncludeSubdirectoryWarningLevel (WarningLevel): cómo tratar los mensajes innecesarios de validación de las rutas de inclusión de subdirectorios de módulos.
$ bRetainFramePointers (Boolean): fuerza la retención de los punteros de fotogramas. Suele hacer falta si quieres pilas de llamadas fiables, como mallocframeprofiler.
$ bRetainFramePointersOverride (Nullable<Boolean>): fuerza la retención de los punteros de fotogramas. Suele hacer falta si quieres pilas de llamadas fiables, como mallocframeprofiler.
$ bUseFastMonoCalls (Boolean): los nuevos controladores de gráficos monolíticos tienen «llamadas rápidas» opcionales que reemplazan varias funciones de D3d.
$ NumIncludedBytesPerUnityCPP (Int32): número aproximado de bytes de código C++ que tomar como destino para incluirlo en un único archivo C++ unificado.
$ bDisableModuleNumIncludedBytesPerUnityCPPOverride (Boolean): deshabilita las anulaciones establecidas por el módulo.
$ bStressTestUnity (Boolean): determina si hacer una prueba de resistencia de la solidez de la compilación de C++ Unity e incluir todos los archivos C++ de un proyecto a partir de un único archivo unificado.
$ bDetailedUnityFiles (Boolean): determina si añadir otra información a los archivos de Unity, como «_of_X» en el nombre del archivo. No recomendado.
$ bForceDebugInfo (Boolean): determina si se fuerza la generación de información de depuración.
$ bDisableDebugInfo (Boolean): determina si se deshabilita globalmente la generación de información de depuración. Obsoleto, utiliza TargetRules.DebugInfoMode en su lugar.
$ DebugInfo (DebugInfoMode): determina cuánta información de depuración debería generarse. Consulta la enumeración DebugInfoMode para obtener más información.
$ DebugInfoLineTablesOnly (DebugInfoMode): se activa si solo se deben emitir tablas de números de línea de depuración en la información de depuración para compiladores que lo admitan. Anula TargetRules.DebugInfo. Consulta https://clang.llvm.org/docs/UsersManual.html#cmdoption-gline-tables-only para obtener más información.
$ bDisableDebugInfoForGeneratedCode (Boolean): determina si se desactiva la generación de información de depuración para los archivos generados. Esto mejora los tiempos de enlace y reduce el tamaño de pdb en los módulos que tienen mucho código de pegamento generado.
$ bOmitPCDebugInfoInDevelopment (Boolean): determina si se deshabilita la información de depuración en PC/Mac en las versiones de desarrollo (para una iteración de desarrollo más rápida, ya que los tiempos de enlace son extremadamente rápidos con la información de depuración deshabilitada).
$ bUsePDBFiles (Boolean): determina si los archivos PDB se utilizan en compilaciones de Visual C++.
$ bUsePCHFiles (Boolean): determina si se utilizan archivos PCH.
$ bDeterministic (Boolean): establece los indicadores necesarios para la compilación y el enlace deterministas. Habilitar el modo determinista para msvc desactiva los subprocesos múltiples de generación de código, por lo que la compilación será más lenta.
$ bChainPCHs (Boolean): determina si las PCH deberían encadenarse al compilar con Clang.
$ bForceIncludePCHHeadersForGenCppFilesWhenPCHIsDisabled (Boolean): determina si se debería forzar la inclusión de los encabezados PCH en los archivos gen.cpp cuando se deshabiliten las PCH.
$ bPreprocessOnly (Boolean): determina si solo se preprocesan los archivos fuente para este destino y se salta la compilación.
$ bPreprocessDepends (Boolean): genera archivos de dependencia mediante preprocesamiento. Esto solo se recomienda al distribuir compilaciones, ya que añade una sobrecarga adicional.
$ bWithAssembly (Boolean): determina si se deben generar o no datos de montaje al compilar este destino. Por ahora, solo funciona en MSVC.
$ bAllowUbaCompression (Boolean): experimental. Almacena el objeto (.obj) comprimido en el disco. Requiere UBA para vincularse, actualmente solo MSVC. Activar o desactivar este indicador invalidará las acciones de MSVC. Advertencia: por el momento, esta opción no es compatible con PGO ni con el enlazador cl-clang, ya que no se desvían y la vinculación fallará.
$ StaticAnalyzer (StaticAnalyzer): determina si debería activarse el análisis de código estático.
$ StaticAnalyzerOutputType (StaticAnalyzerOutputType): el tipo de salida que usará el analizador estático. Esto solo es compatible con Clang.
$ StaticAnalyzerMode (StaticAnalyzerMode): el modo que se usará para el analizador estático. Esto solo es compatible con Clang. El modo superficial se completa más rápido, pero por lo general no se recomienda.
$ StaticAnalyzerPVSPrintLevel (Int32): el nivel de advertencias que se mostrarán al analizar con PVS-Studio.
$ bStaticAnalyzerProjectOnly (Boolean): solo ejecuta el análisis estático en los módulos del proyecto y se omiten los módulos del motor.
$ bStaticAnalyzerIncludeGenerated (Boolean): cuando se activa, se analizan los archivos de origen generados.
$ MinFilesUsingPrecompiledHeader (Int32): el número mínimo de archivos que deben usar un encabezado precompilado antes de que se creen y usen.
$ bForcePrecompiledHeaderForGameModules (Boolean): si se habilita esta opción, siempre se genera un encabezado precompilado para los módulos del juego, aunque el módulo contenga unos pocos archivos de origen. Esto mejora considerablemente los tiempos de compilación para los cambios iterativos en algunos archivos del proyecto, a expensas de que volver a realizar una compilación completa lleve más tiempo con los proyectos de juegos pequeños. Esto se puede anular al configurar MinFilesUsingPrecompiledHeaderOverride en el archivo Build.cs de un módulo.
$ bUseIncrementalLinking (Boolean): determina si usar la vinculación incremental. La vinculación incremental puede acelerar los tiempos de iteración al realizar pequeños cambios. Actualmente, está deshabilitado de forma predeterminada porque suele presentar un comportamiento un tanto defectuoso en algunos ordenadores (errores de compilar relacionados con la PDB).
$ bAllowLTCG (Boolean): permite el uso de generación de código en tiempo de enlace (LTCG).
$ bPreferThinLTO (Boolean): cuando se activa la generación de código en tiempo de enlace (LTCG), indica si se prefiere usar la versión más ligera en las plataformas compatibles.
$ ThinLTOCacheDirectory (String): directorio donde colocar la caché de ThinLTO en las plataformas compatibles.
$ ThinLTOCachePruningArguments (String): argumentos que se aplicarán para eliminar la caché de ThinLTO en las plataformas compatibles. Los argumentos solo se aplicarán si se ha establecido ThinLTOCacheDirectory.
$ bPGOProfile (Boolean): determina si se activa la instrumentación de optimización guiada por perfil (PGO) en esta compilación.
$ bPGOOptimize (Boolean): determina si optimizar esta compilación con la optimización guiada por perfil (PGO).
$ bCodeCoverage (Boolean): determina si el destino requiere compilar y vincular la cobertura de código.
$ bSupportEditAndContinue (Boolean): determina si se admite editar y continuar.
$ bOmitFramePointers (Boolean): determina si se deben omitir o no los punteros de fotogramas. Deshabilitarlo es útil para, por ejemplo, el perfilado de memoria en el PC.
$ bCompressDebugFile (Boolean): indica si queremos comprimir los archivos de depuración.
$ bEnableCppModules (Boolean): determina si se debe habilitar el soporte para módulos C++20.
$ bEnableCppCoroutinesForEvaluation (Boolean): determina si se debe activar o no la compatibilidad con corrutinas de C++20. Esta opción se proporciona para facilitar la evaluación de la función. El nombre de la opción cambiará. El uso de corrutinas en UE aún no se ha probado y no cuenta con asistencia técnica.
$ bEnableProcessPriorityControl (Boolean): determina si se activa o no la capacidad del motor para establecer la prioridad de los procesos en tiempo de ejecución. Esta opción requiere cierta configuración del entorno en Linux, por lo que está desactivada por defecto. El proyecto tiene que habilitar esta función para garantizar una configuración correcta.
$ bUseMallocProfiler (Boolean): si está activado, habilita el perfilado de memoria en la compilación (define USE_MALLOC_PROFILER=1 y fuerza bOmitFramePointers=false).
$ bShaderCompilerWorkerTrace (Boolean): si está activado, se habilita la generación de perfiles de Unreal Insights (utrace) en la compilación para el trabajador del compilador de sombreadores (define USE_SHADER_COMPILER_WORKER_TRACE=1).
$ bUseSharedPCHs (Boolean): activa los «PCH compartidos», una función que acelera significativamente los tiempos de compilación al intentar compartir ciertos archivos PCH entre módulos que UBT detecta que incluyen los archivos de encabezado de dichos PCH.
$ bUseShippingPhysXLibraries (Boolean): se activa si las compilaciones de desarrollo y versión deben usar la configuración de versión de PhysX/APEX.
$ bUseCheckedPhysXLibraries (Boolean): se activa si las compilaciones de desarrollo y lanzamiento deben usar la configuración marcada de PhysX/APEX. Si se activa bUseShippingPhysXLibraries, se ignorará.
$ bCheckLicenseViolations (Boolean): le dice a UBT que compruebe si el módulo que se está compilando infringe el CLUF.
$ bBreakBuildOnLicenseViolation (Boolean): indica a UBT que interrumpa la compilación si el módulo que se está compilando infringe el CLUF.
$ bUseFastPDBLinking (Nullable<Boolean>): determina si usar la opción :FASTLINK al compilar con /DEBUG para crear PDB locales en Windows. Es rápido, pero ahora mismo parece tener problemas para encontrar símbolos en el depurador.
$ bCreateMapFile (Boolean): genera un archivo de mapa como parte de la compilación.
$ bAllowRuntimeSymbolFiles (Boolean): se activa si los archivos de símbolos de tiempo de ejecución deben generarse como paso posterior a la compilación en algunas plataformas. El motor usa estos archivos para resolver los nombres de los símbolos de seguimiento de las pilas de llamadas en los registros.
$ PackagePath (String): ruta completa del paquete (directorio + nombre de archivo) donde almacenar los archivos de entrada usados en el momento del enlace. Normalmente se usa para depurar un fallo del enlazador para las plataformas que lo admiten.
$ CrashDiagnosticDirectory (String): directorio donde se almacenan los archivos de informes de fallos para las plataformas que lo admitan.
$ BundleVersion (String): versión del paquete para las apps de Mac.
$ bDeployAfterCompile (Boolean): determina si se implementa el archivo ejecutable después de la compilación en plataformas que requieran implementación.
$ bAllowRemotelyCompiledPCHs (Boolean): cuando se activa, permite que XGE compile archivos de encabezado precompilados en máquinas remotas. De lo contrario, los PCH siempre se generan localmente.
$ bUseHeaderUnitsForPch (Boolean): reemplazará pch por ifc y usará unidades de encabezado en su lugar. Esta es una función experimental y solo es para MSVC.
$ bCheckSystemHeadersForModification (Boolean): determina si se deben comprobar los encabezados de las rutas del sistema para ver si hay modificaciones al determinar acciones obsoletas.
$ bDisableLinking (Boolean): determina si se desactiva la vinculación para este destino.
$ bIgnoreBuildOutputs (Boolean): determina si se debe ignorar o no el seguimiento de las salidas de compilación para este destino.
$ bDisableEngineDeprecations (Boolean): determina si se deshabilitan las advertencias de desactivación de UE_DEPRECATED_FORENGINE en módulos que no sean del motor. Esto solo debería usarse a corto plazo, ya que estos elementos obsoletos se eliminarán.
$ bFormalBuild (Boolean): indica que se trata de una compilación formal destinada a la distribución. Este indicador se activa automáticamente cuando Build.version tiene una lista de cambios establecida y es una compilación promocionada. El único comportamiento actualmente vinculado a este indicador es compilar el archivo de recursos predeterminado por separado para cada binario, de modo que el campo OriginalFilename se establezca correctamente. Por defecto, solo compilamos el recurso una vez para reducir los tiempos de compilación.
$ bFlushBuildDirOnRemoteMac (Boolean): determina si se debe limpiar el directorio de compilaciones en un Mac remoto antes de compilar.
$ bPrintToolChainTimingInfo (Boolean): determina si se debe escribir información detallada de tiempo desde el compilador y el enlazador.
$ bParseTimingInfoForTracing (Boolean): determina si se deben analizar los datos de tiempo y convertirlos en un archivo de trazado compatible con chrome://tracing.
$ bPublicSymbolsByDefault (Boolean): determina si se deben exponer todos los símbolos como públicos de forma predeterminada en las plataformas POSIX.
$ bDisableInliningGenCpps (Boolean): desactiva la compatibilidad con la integración en línea de gen.cpps.
$ ToolChainName (String): permite anular la cadena de herramientas que se creará para este destino. Debe coincidir con el nombre de una clase declarada en el montaje de UnrealBuildTool.
$ MSVCCompileActionWeight (Single): el peso (uso de CPU/memoria) de una acción de compilación de MSVC.
$ ClangCompileActionWeight (Single): el peso (uso de CPU/memoria) de una acción de compilación de Clang.
$ bDisableUnverifiedCertificates (Boolean): determina si se debe permitir que la configuración del motor defina si podemos cargar certificados no verificados.
$ bAllowGeneratedIniWhenCooked (Boolean): determina si se deben cargan los archivos .ini generados en la compilación procesada (GameUserSettings.ini se carga de cualquier forma).
$ bAllowNonUFSIniWhenCooked (Boolean): determina si se deben cargar o no archivos .ini que no sean ufs en una compilación procesada (GameUserSettings.ini se cargará de cualquier forma).
$ bLegacyPublicIncludePaths (Boolean): añade todas las carpetas públicas como rutas de inclusión para el entorno de compilación.
$ bLegacyPublicIncludePaths (Boolean): añade todas las carpetas padre como rutas de inclusión para el entorno de compilación.
$ CppStandardEngine (CppStandardVersion): determina qué estándar C++ utilizar para compilar este destino (para los módulos del motor).
$ CppStandard (CppStandardVersion): determina qué estándar C++ utilizar para compilar este destino (para módulos que no sean del motor).
$ CStandard (CStandardVersion): determina qué estándar de C utilizar para compilar este destino.
$ MinCpuArchX64 (MinimumCpuArchitectureX64): indica al compilador que genere instrucciones AVX siempre que se usen intrínsecos SSE o AVX en las plataformas x64 compatibles. Se ignora para arm64. Ten en cuenta que, al activarlo, cambias las especificaciones mínimas de la plataforma de destino, y el archivo ejecutable resultante se bloqueará en máquinas que no sean compatibles con AVX.
$ BuildVersion (String): la cadena de la versión de compilación.
$ LinkType (TargetLinkType): especifica cómo vincular módulos en este destino (monolítico o modular). Actualmente, está protegido por compatibilidad con versiones anteriores. Llama al elemento de acceso GetLinkType() hasta que se elimine la compatibilidad con la anulación en desuso ShouldCompileMonolithic().
$ bStripExports (Boolean): experimental. Elimina las exportaciones no utilizadas de las bibliotecas. Solo se aplica cuando LinkType es modular
$ bMergeModules (Boolean): experimental. Fusiona módulos modulares en bibliotecas combinadas. Establece LinkType como modular y activa bStripExports.
$ LaunchModuleName (String): especifica el nombre del módulo de lanzamiento. En el caso de las compilaciones modulares, es el módulo que se compila en el archivo ejecutable del destino.
$ ExportPublicHeader (String): especifica la ruta para escribir un encabezado que contenga definiciones públicas para este destino. Es útil a la hora de compilar un archivo DLL para que lo consuman procesos de compilación externos.
$ BuildEnvironment (TargetBuildEnvironment): especifica el entorno de compilación para este destino. Consulta TargetBuildEnvironment para obtener más información sobre las opciones disponibles.
$ bAllowSDKOverrideModulesWithSharedEnvironment (Boolean): si está activado, un destino de entorno de compilación compartido permitirá que cualquier módulo que sea sensible a la versión del SDK tenga un módulo del proyecto cuando se anule un SDK. Por ejemplo, si IOSTargetPlatform, que está marcado como relevante para la versión del SDK de IOS, se compila para un objetivo con esto activado, y ese destino anula el SDK de IOS, entonces esto se compilaría, por ejemplo, en MyProject/Binaries/Win64/IOS/MyProject-IOSTargetPlatform.dll
$ bOverrideBuildEnvironment (Boolean): determina si se ignoran las infracciones en el entorno de compilación poses compartidas (p. ej., destinos del editor que modifican definiciones).
$ AdditionalCompilerArguments (String): argumentos adicionales para pasar al compilador.
$ AdditionalLinkerArguments (String): argumentos adicionales para pasar al enlazador.
$ MemoryPerActionGB (Double): cantidad máxima de memoria que puede necesitar cada acción de compilar. Lo usa ParallelExecutor para decidir el número máximo de acciones paralelas que se iniciarán a la vez.
$ GeneratedProjectName (String): al generar archivos de proyecto, especifica el nombre del archivo de proyecto que se usará cuando haya varios destinos del mismo tipo.