Los módulos son los componentes básicos de Unreal Engine (UE). El motor se implementa como una gran colección de módulos, y los juegos proporcionan sus propios módulos para aumentarlos. Cada módulo encapsula un conjunto de funciones y puede proporcionar una interfaz pública y un entorno de compilación (con macros, rutas de inclusión, etc.) para que los usen otros módulos.
Los módulos se declaran a través de archivos fuente de C# con la extensión .build.cs y se almacenan en el directorio Source de tu proyecto. El código fuente de C++ que pertenece a un módulo se almacena junto al archivo .build.cs o en subdirectorios del mismo. Cada archivo .build.cs declara una clase derivada de la clase base ModuleRules y establece propiedades que controlan cómo debe compilarse a partir de su constructor. Estos archivos .build.cs se compilan con la herramienta Unreal Build Tool (UBT) y se construyen para determinar el entorno de compilación general.
La estructura típica de un archivo .build.cs es la siguiente.
using UnrealBuildTool;
using System.Collections.Generic;
public class MyModule : ModuleRules
{
public MyModule(ReadOnlyTargetRules Target) : base(Target)
{
// Properties and settings go here
}
}Propiedades de solo lectura
$ IsPlugin (Boolean): activado si un complemento contiene este módulo.
$ Logger (ILogger): descriptor de acceso para el registrador de destino.
$ HasPackageOverride (Boolean): se activa si se ha especificado un tipo de anulación en este módulo.
$ ForceIncludeFiles (List<String>): archivos de encabezado que deberían incluirse a la fuerza en cada archivo fuente de este módulo.
$ SDKVersionRelevantPlatforms (List<UnrealTargetPlatform>): si contiene una plataforma y se ha anulado la versión predeterminada del SDK del proyecto, este módulo se compilará como un módulo del proyecto, en lugar de como un módulo de motor compartido.
$ StaticAnalyzerCheckers (HashSet<String>): los verificadores del analizador estático que deben activarse en lugar de los predeterminados. Esto solo es compatible con Clang. Consulta https://clang.llvm.org/docs/analyzer/checkers.html para ver una lista completa. También puedes ejecutar: 'Clang -Xclang -Analyzer-checker-help' o 'Clang -Xclang -Analyzer-checker-help-alpha' para ver la lista de verificadores experimentales.
$ StaticAnalyzerDisabledCheckers (HashSet<String>): los verificadores predeterminados del analizador estático que deben estar desactivados. No se usa si se rellena StaticAnalyzerCheckers. Esto solo es compatible con Clang. Consulta https://clang.llvm.org/docs/analyzer/checkers.html para ver una lista completa. También puedes ejecutar: 'Clang -Xclang -Analyzer-checker-help' o 'Clang -Xclang -Analyzer-checker-help-alpha' para ver la lista de verificadores experimentales.
$ StaticAnalyzerAdditionalCheckers (HashSet<String>): los verificadores no predeterminados del analizador estático que deben activarse. No se usa si se rellena StaticAnalyzerCheckers. Esto solo es compatible con Clang. Consulta https://clang.llvm.org/docs/analyzer/checkers.html para ver una lista completa. También puedes ejecutar: 'Clang -Xclang -Analyzer-checker-help' o 'Clang -Xclang -Analyzer-checker-help-alpha' para ver la lista de verificadores experimentales.
$ StaticAnalyzerPVSDisabledErrors (HashSet<String>): los errores de análisis de PVS Studio que deberían desactivarse.
$ AutoSdkDirectory (String): el directorio de AutoSDK para la plataforma host activa.
$ EngineDirectory (String): el directorio actual del motor.
$ PluginDirectory (String): propiedad del directorio que contiene este complemento. Útiles para añadir rutas a dependencias de terceros.
$ ModuleDirectory (String): propiedad del directorio que contiene este módulo. Útiles para añadir rutas a dependencias de terceros.
$ TestsDirectory (String): devuelve el directorio de pruebas de nivel inferior del módulo «Tests».
$ IsVcPackageSupported (Boolean): se devuelve si VcPkg es compatible con la configuración de compilación.
Propiedades de lectura/escritura
$ StaticAnalyzerRulesets (HashSet<FileReference>): el conjunto de reglas del analizador estático que deberían usarse para filtrar las advertencias. Esto solo es compatible con MSVC. Consulta https://learn.microsoft.com/es-es/cpp/code-quality/using-rule-sets-to-specify-the-cpp-rules-to-run.
$ AllowedRestrictedFolders (List<String>): lista de carpetas a las que se puede hacer referencia al compilar este binario, sin propagar nombres de carpetas restringidas
$ AliasRestrictedFolders (Dictionary<String, String>): conjunto de referencias de carpetas restringidas con alias.
$ PublicIncludePathModuleNames (List<String>): lista de nombres de módulos (sin necesidad de ruta) con archivos de encabezado a los que los encabezados públicos de nuestro módulo necesitan acceder, pero no es necesario que nosotros importemos o enlacemos.
$ PublicDependencyModuleNames (List<String>): lista de nombres de módulos de dependencia públicos (no se necesita ruta) (la inclusión pública/privada se añade automáticamente). Estos son módulos necesarios para nuestros archivos de código fuente públicos.
$ PrivateIncludePathModuleNames (List<String>): lista de nombres de módulos (sin necesidad de ruta) con archivos de encabezado a los que los archivos de código privado de nuestro módulo necesitan acceder, pero no es necesario que nosotros importemos o enlacemos.
$ PrivateDependencyModuleNames (List<String>): lista de nombres de módulos de dependencia privados. Se trata de módulos de los que depende nuestro código privado, pero de los que no dependen nuestros archivos de inclusión públicos.
$ CircularlyReferencedDependentModules (List<String>): solo por motivos heredados, no debería usarse en código nuevo. Lista de dependencias de módulos que deberían tratarse como referencias circulares. Estos módulos deben haberse añadido ya a la lista de módulos dependientes públicos o privados.
$ PublicSystemIncludePaths (List<String>): lista de rutas de inclusión del sistema/bibliotecas. Normalmente se usa para módulos externos (de terceros). Son directorios de archivos de encabezado estables y públicos que no se comprueban a la hora de resolver las dependencias de encabezados.
$ PublicIncludePaths (List<String>): (este ajuste no es necesario actualmente, ya que detectamos todos los archivos de la carpeta 'Public”.) Lista de todas las rutas para incluir archivos que están expuestos a otros módulos.
$ InternalIncludePaths (List<String>): (este ajuste no es necesario actualmente, ya que detectamos todos los archivos de la carpeta 'Internal”). Lista de todas las rutas para incluir archivos que están expuestos a otros módulos internos
$ PrivateIncludePaths (List<String>): lista de todas las rutas a los archivos de inclusión internos de este módulo, no expuestas a otros módulos (al menos una inclusión a la ruta 'Private', más si queremos evitar rutas relativas).
$ PublicSystemLibraryPaths (List<String>): lista de rutas de las bibliotecas del sistema (directorio de archivos .lib). Para módulos externos (de terceros), usa PublicAdditionalLibaries en su lugar
$ PrivateRuntimeLibraryPaths (List<String>): lista de rutas de búsqueda de bibliotecas en tiempo de ejecución (p. ej., archivo .so).
$ PublicRuntimeLibraryPaths (List<String>): lista de rutas de búsqueda de bibliotecas en tiempo de ejecución (p. ej., archivo .so).
$ PublicAdditionalLibraries (List<String>): lista de bibliotecas adicionales (nombres de los archivos .lib incluida la extensión). Normalmente se usan para módulos de terceros.
$ PublicDebugVisualizerPaths (List<String>): lista de visualizadores de depuración adicionales (.natvis y .natstepfilter) expuestos a otros módulos. Se suele usar para módulos externos (de terceros).
$ DependenciesToSkipPerArchitecture (Dictionary<String, List<UnrealArch>>): listas por arquitectura de dependencias para que la vinculación las ignore (útil al compilar para varias arquitecturas y solo se necesita un archivo .lib para una arquitectura). La cadena de herramienta decide si las utiliza.
$ PublicPreBuildLibraries (List<String>): lista de bibliotecas precompiladas adicionales (nombres de los archivos .lib incluida la extensión): se usan normalmente para destinos adicionales que aún se compilan, pero usando TargetRules.PreBuildSteps o TargetRules.PreBuildTargets.
$ PublicSystemLibraries (List<String>): lista de bibliotecas del sistema que se usarán. Por lo general, se hace referencia a ellas mediante el nombre y luego se encuentran a través de las rutas del sistema. Si necesitas referenciar un archivo .lib utiliza PublicAdditionalLibraries en su lugar.
$ PublicFrameworks (List<String>): lista de marcos XCode (iOS y MacOS).
$ PublicWeakFrameworks (List<String>): lista de marcos débiles (para transiciones de versiones de SO).
$ PublicAdditionalFrameworks (List<Framework>): lista de marcos adicionales. Normalmente se usa para módulos externos (de terceros) en Mac y iOS.
$ AdditionalBundleResources (List<BundleResource>): lista de recursos adicionales que deberían copiarse en el paquete de apps para Mac o iOS
$ TypeLibraries (List<TypeLibrary>): lista de bibliotecas de tipos para las que necesitamos generar encabezados (solo Windows).
$ PublicDelayLoadDLLs (List<String>): lista de archivos DLL de carga de retraso. Normalmente se usa para módulos externos (de terceros).
$ PrivateDefinitions (List<String>): definiciones privadas del compilador para este módulo.
$ PublicDefinitions (List<String>): definiciones públicas del compilador para este módulo.
$ DynamicallyLoadedModuleNames (List<String>): módulos adicionales que este módulo puede necesitar durante la ejecución.
$ RuntimeDependencies (RuntimeDependencyList): lista de archivos de los que depende este módulo durante la tiempo de ejecución. Estos archivos se prepararán junto con el destino.
$ AdditionalPropertiesForReceipt (ReceiptPropertyList): lista de propiedades adicionales que se añadirán a la confirmación de la compilación.
$ ExternalDependencies (List<String>): archivos externos que invalidan el archivo MAKE si se modifican. Las rutas relativas se resuelven en relación con el archivo .build.cs.
$ SubclassRules (List<String>): archivos de reglas de subclases que invalidan el archivo MAKE si se modifican.
$ GenerateHeaderFuncs (List<ValueTuple<String, Action<ILogger, DirectoryReference>>>): lista de nombres de subdirectorios y funciones que se invocan para generar archivos de encabezado. El nombre del subdirectorio se añade al directorio del código generado para formar un nuevo directorio en el que se generan los encabezados.
$ Nombre (String): nombre de este módulo.
$ Type (ModuleType): tipo de módulo
$ anularPackageType (PackageOverrideType): tipo de módulo que establecerá distintos indicadores de paquetes. No se puede usar para módulos que forman parte de un complemento, ya que ya está establecido en el archivo `.uplugin`.
$ BinariesSubFolder (String): subcarpeta de la carpeta Binaries/PLATFORM en la que colocar este módulo al compilar archivos DLL. Solo deberían usarlo módulos que se encuentren al buscar, como los módulos TargetPlatform o ShaderFormat. Si no se usa FindModules para un hacer seguimiento, los módulos no se encontrarán.
$ OptimizeCode (CodeOptimization): cuándo debería optimizarse el código de este módulo.
$ OptimizationLevel (OptimizationMode): permite ajustar el nivel de optimización para la velocidad o de tamaño del código. Esto requiere un PCH privado (o NoPCHs, lo cual no es recomendable).
$ FPSemantics (FPSemanticsMode): permite anular la semántica de los FP para este módulo. Esto requiere un PCH privado (o NoPCHs, lo cual no es recomendable).
$ PrivatePCHHeaderFile (String): PCH privado explícito para este módulo. Implica que este módulo no usará un PCH compartido.
$ SharedPCHHeaderFile (String): nombre de archivo de encabezado para un archivo PCH compartido proporcionado por este módulo. Debe ser una ruta relativa válida a un archivo de encabezado C++ público. Esto solo debería establecerse para archivos de encabezado incluidos en un número significativo de otros módulos de C++.
$ ShortName (String): especifica un nombre alternativo para los directorios intermedios y los archivos para los intermediarios de este módulo. Es útil cuando hay limitaciones en la longitud de la ruta.
$ PCHUsage (PCHUsageMode): uso de encabezados precompilados para este módulo.
$ bTreatAsEngineModule (Boolean): determina si este módulo debería tratarse como un módulo de motor (p. ej., usando definiciones del motor, PCH, compilación con optimizaciones activada en las configuraciones de DebugGame, etc.). Se inicializa con un valor predeterminado basado en el conjunto de reglas a partir del cual se creó.
$ bValidateFormatStrings (Boolean): emite errores de compilación para cadenas con formato UE_LOG incorrecto.
$ bValidateInternalApi (Boolean): emite advertencias\errores en desuso para el uso interno de la API para módulos que no sean del motor.
$ DefaultBuildSettings (BuildSettingsVersion): qué ajustes de compilación de la versión del motor se usarán por defecto.
$ IncludeOrderVersion (EngineIncludeOrderVersion): qué versión del orden de inclusión usar al compilar este módulo. Se puede anular con -ForceIncludeOrder en la línea de comandos o en las reglas de un módulo.
$ bUseRTTI (Boolean): usa la información de tipo en tiempo de ejecución
$ bVcRemoveUnreferencedComdat (Boolean): determina si indicar a MSVC que elimine las funciones y los datos de COMDAT no referenciados.
$ bCodeCoverage (Boolean): activa la compatibilidad con la compilación/vinculación de la cobertura de código.
$ bUseAVX (Boolean): obsoleto. Indica al compilador que genere instrucciones AVX siempre que se usen intrínsecos SSE o AVX en las plataformas compatibles. Ten en cuenta que, al activarlo, cambias las especificaciones mínimas de la plataforma PC, y el archivo ejecutable resultante se bloqueará en equipos que no sean compatibles con AVX.
$ MinCpuArchX64 (Nullable<MinimumCpuArchitectureX64>): indica al compilador que genere instrucciones AVX siempre que se usen intrínsecos SSE o AVX en las plataformas x64 compatibles. Ten en cuenta que, al activarlo, cambias las especificaciones mínimas de la plataforma PC, y el archivo ejecutable resultante se bloqueará en equipos que no sean compatibles con AVX.
$ bEnableBufferSecurityChecks (Boolean): activa las comprobaciones de seguridad del búfer. Por lo general, debería activarse, ya que evita riesgos de seguridad graves.
$ bEnableExceptions (Boolean): activa el manejo de excepciones.
$ bEnableObjCExceptions (Boolean): activa el manejo de excepciones de Objetive C.
$ bEnableObjCAutomaticReferenceCounting (Boolean): activa el recuento automático de referencias (ARC) de Objetive C. Si activas esta opción, no deberías usa PCH compartidos para este módulo. El motor no usará mucho ARC a corto plazo. No hacerlo provocará errores de compilación porque los PCH compartidos se compilaron con indicadores distintos a los del consumidor.
$ DeterministicWarningLevel (WarningLevel): cómo tratar las advertencias deterministas (experimental).
$ ShadowVariableWarningLevel (WarningLevel): cómo tratar los avisos de las variables de sombras.
$ 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): cómo tratar las advertencias de conversión de tipo implícitas no seguras (p. ej., double->float o int64->int32).
$ UndefinedIdentifierWarningLevel (WarningLevel): indica qué nivel de advertencia/error otorgar a los identificadores indefinidos en las expresiones condicionales.
$ bEnableUndefinedIdentifierWarnings (Boolean): activa las advertencias por usar identificadores indefinidos en expresiones #if.
$ 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.
$ bDisableStaticAnalysis (Boolean): desactiva todos los análisis estáticos: clang, msvc, pvs-studio.
$ bStaticAnalyzerExtensions (Boolean): activa las advertencias adicionales de la extensión del analizador mediante el complemento EspXEngine. Esto solo es compatible con MSVC. Consulta https://learn.microsoft.com/es-es/cpp/code-quality/using-the-cpp-core-guidelines-checkers. Esto añadirá un gran número de advertencias por defecto. Se recomienda utilizar StaticAnalyzerRulesets si está activado.
$ bUseUnity (Boolean): si las compilaciones unitarias están activadas, se puede usar para anular si este módulo específico se compilará usando Unity. Esto se establece usando las configuraciones por módulo en BuildConfiguration.
$ bMergeUnityFiles (Boolean): determina si fusionar el módulo y los archivos Unity generados para compilar más rápido.
$MinSourceFilesForUnityBuildOverride (Int32): número de archivos de origen en este módulo antes de que se active la compilación de Unity para ese módulo. Si se establece en cualquier valor que no sea -1, se anulará la configuración predeterminada, que se controla mediante MinGameModuleSourceFilesForUnityBuild.
$ MinFilesUsingPrecompiledHeaderOverride (Int32): anula BuildConfiguration.MinFilesUsingPrecompiledHeader si es distinto de cero.
$ NumIncludedBytesPerUnityCPPOverride (Int32): anula Target.NumIncludedBytesPerUnityCPP si es distinto de cero.
$ bBuildLocallyWithSNDBS (Boolean): el módulo usa una #importación, por lo que debe compilarse localmente al compilar con SN-DBS
$ bEnableNonInlinedGenCppWarnings (Boolean): activa las advertencias para cuando haya archivos .gen.cpp que podrían incluirse en un archivo cpp escrito a mano.
$ IsRedistributableOverride (Nullable<Boolean>): indicador de anulación de redistribución para este módulo.
$ bLegalToDistributeObjectCode (Boolean): determina si la salida de este módulo puede distribuirse públicamente, incluso si tiene código/dependencias en módulos que no lo están (es decir, CarefullyRedist, NotForLicensees, NoRedist). Debería usarse cuando vayas a liberar binarios pero no fuentes.
$ bEnforceIWYU (Boolean): aplica las reglas «incluir lo que uses» cuando PCHUsage se establece como ExplicitOrSharedPCH; advierte cuando se utilizan encabezados monolíticos (Engine.h, UnrealEd.h, etc.) y comprueba que los archivos fuente incluyan primero su encabezado correspondiente.
$ IWYUSupport (IWYUSupport): permite que «incluir lo que uses» modifique el código fuente al ejecutarse. bEnforceIWYU debe estar activado para que esta variable tenga efecto.
$ bAddDefaultIncludePaths (Boolean): determina si se añaden o no todas las rutas de inclusión predeterminadas al módulo (p. ej., la carpeta Source/Classes, subcarpetas bajo Source/Public).
$ bIgnoreUnresolvedSymbols (Boolean): determina si se ignoran los símbolos colgantes (es decir, no resueltos externos) en los módulos.
$ bPrecompile (Boolean): determina si este módulo debería precompilarse. El valor predeterminado es el indicador bPrecompile del destino. Borra este indicador para evitar que se precompile un módulo.
$ bUsePrecompiled (Boolean): determina si este módulo debería usar datos precompilados. Siempre está activado para los módulos creados a partir de conjuntos instalados.
$ bAllowConfidentialPlatformDefines (Boolean): define si este módulo puede usar definiciones de estilo PLATFORM_XXXX, donde XXXX es el nombre de una plataforma confidencial. Esto se usa para garantizar que el motor u otro código compartido no revele información confidencial dentro de un bloque #if PLATFORM_XXXX. No obstante, es posible que el código del juego del licenciatario quiera tenerlas en cuenta.
$ bDisableAutoRTFMInstrumentation (Boolean): desactiva la instrumentación de AutoRTFM para este módulo solo cuando AutoRTFMCompiler esté activado.
$ PrecompileForTargets (PrecompileTargetsType): destinos para los que debería precompilarse este módulo.
$ bRequiresImplementModule (Nullable<Boolean>): determina si este módulo requiere la macro IMPLEMENT_MODULE para implementarse. La mayoría de los módulos de UE lo requieren, ya que usamos la macro IMPLEMENT_MODULE para sobrecargar otras funciones globales (p. ej., reenvío de operadores nuevos/eliminación a GMalloc).
$ bLegacyPublicIncludePaths (Boolean): determina si este módulo cumple los requisitos de los encabezados incluidos de otros módulos en relación con la raíz de su carpeta 'Public'. Esto reduce el número de rutas de búsqueda que hay que pasar al compilador, lo que mejora el rendimiento y reduce la longitud de la línea de comandos del compilador.
$ bLegacyParentIncludePaths (Boolean): determina si este módulo cumple los requisitos de los encabezados incluidos de otros módulos relativos al directorio padre. Esto reduce el número de rutas de búsqueda que hay que pasar al compilador, lo que mejora el rendimiento y reduce la longitud de la línea de comandos del compilador.
$ bValidateCircularDependencies (Boolean): determina si las dependencias circulares se validarán con la lista de permitidos. Las dependencias circulares de los módulos ralentizan las compilaciones. Se desaconseja encarecidamente desactivar esta opción. Esta opción se ignora para los módulos del motor, que siempre se validarán con respecto a la lista de elementos permitidos.
$ CppStandard (Nullable<CppStandardVersion>): determina qué estándar utilizar para compilar este módulo.
$ CStandard (Nullable<CStandardVersion>): determina qué estándar utilizar para compilar este módulo.
$ ModuleSymbolVisibility (SymbolVisibility): controla la visibilidad de los símbolos.