Módulos são os blocos de construção da Unreal Engine (UE). A engine é implementada como uma grande coleção de módulos, e os jogos fornecem seus próprios módulos para aprimorá-la. Cada módulo encapsula um conjunto de funcionalidades e pode fornecer uma interface pública e um ambiente de compilação (com macros, caminhos de inclusão e assim por diante) para uso por outros módulos.
Os módulos são declarados por meio de arquivos de origem C# com uma extensão .build.cs e são armazenados no diretório de origem do seu projeto. O código-fonte C++ pertencente a um módulo é armazenado ao lado do arquivo .build.cs ou de seus subdiretórios. O arquivo .build.cs declara uma classe derivada da classe-base ModuleRules e define propriedades para controlar como ela deve ser construída com base no seu constructor. Os arquivos .build.cs são compilados pela Unreal Build Tool (UBT) e construídos para determinar o ambiente geral de compilação.
A estrutura típica para um arquivo .build.cs é conforme a seguir.
using UnrealBuildTool;
using System.Collections.Generic;
public class MyModule : ModuleRules
{
public MyModule(ReadOnlyTargetRules Target) : base(Target)
{
// Properties and settings go here
}
}Propriedades somente leitura
$ IsPlugin (booleano): verdadeiro se um plugin contém este módulo
$ Logger (ILogger): acessador para o registrador de destino
$ HasPackageOverride (booleano): retorna verdadeiro se houver um tipo de substituição especificado neste módulo
$ ForceIncludeFiles (List<String>): arquivos de cabeçalho que devem ter a inclusão forçada em cada arquivo de código-fonte neste módulo.
$ SDKVersionRelevantPlatforms (List<UnrealTargetPlatform>): se contiver uma plataforma e a versão do SDK tiver sido sobreposta por padrão no projeto, este módulo será compilado como um módulo de projeto em vez de um módulo compartilhado da engine.
$ StaticAnalyzerCheckers (HashSet<String>): os verificadores do analisador estático que devem ser habilitados em vez dos padrões. Isso apenas é compatível com o Clang. Confira https://clang.llvm.org/docs/analyzer/checkers.html para obter uma lista completa. Ou execute: "clang -Xclang -analyzer-checker-help" ou então: "clang -Xclang -analyzer-checker-help-alpha" para obter a lista de verificadores experimentais.
$ StaticAnalyzerDisabledCheckers (HashSet<String>): os verificadores padrão do analisador estático que devem ser desabilitados. Não serão usados se "StaticAnalyzerCheckers" estiver preenchido. Isso apenas é compatível com o Clang. Confira https://clang.llvm.org/docs/analyzer/checkers.html para obter uma lista completa. Ou execute: "clang -Xclang -analyzer-checker-help" ou então: "clang -Xclang -analyzer-checker-help-alpha" para obter a lista de verificadores experimentais.
$ StaticAnalyzerAdditionalCheckers (HashSet<String>): os verificadores não padrão do analisador estático que devem ser habilitados. Não serão usados se "StaticAnalyzerCheckers" estiver preenchido. Isso apenas é compatível com o Clang. Confira https://clang.llvm.org/docs/analyzer/checkers.html para obter uma lista completa. Ou execute: "clang -Xclang -analyzer-checker-help" ou então: "clang -Xclang -analyzer-checker-help-alpha" para obter a lista de verificadores experimentais.
$ StaticAnalyzerPVSDisabledErrors (HashSet<String>): os erros de análise do PVS Studio que devem ser desabilitados.
$ AutoSdkDirectory (String): o diretório AutoSDK da plataforma do host ativo
$ EngineDirectory (String): o diretório atual da engine
$ PluginDirectory (String): a propriedade para o diretório que contém este plugin. Úteis para adicionar caminhos a dependências de terceiros.
$ ModuleDirectory (String): a propriedade para o diretório que contém este módulo. Úteis para adicionar caminhos a dependências de terceiros.
$ TestsDirectory (string): retorna o diretório "Tests" dos testes de baixo nível do módulo.
$ IsVcPackageSupported (booleano): retorna se VcPKg for suportado para a configuração de compilação.
Propriedades de gravação/leitura
$ StaticAnalyzerRulesets (HashSet<FileReference>): os conjuntos de regras do analisador estático que devem ser usados para filtrar avisos. Isso apenas é compatível com o MSVC. Confira https://learn.microsoft.com/pt-br/cpp/code-quality/using-rule-sets-to-specify-the-cpp-rules-to-run
$ AllowedRestrictedFolders (List<String>): a lista de pastas permitidas para serem usadas como referência ao compilar este binário, sem propagar nomes de pastas restritos
$ AliasRestrictedFolders (Dictionary<String, String>): o conjunto de referências de pastas restritas com aliases
$ PublicIncludePathModuleNames (List<String>): lista de nomes de módulos (sem caminho necessário) com arquivos de cabeçalho que os cabeçalhos públicos do módulo precisam acessar, mas não precisamos "importar" nem vincular.
$ PublicDependencyModuleNames (List<String>): lista de nomes de módulo de dependência pública (sem caminho necessário) (inclui a propriedade privada/pública de forma automática). Esses módulos são exigidos pelos arquivos de código-fonte públicos.
$ PrivateIncludePathModuleNames (List<String>): lista de nomes de módulos (sem caminho necessário) com arquivos de cabeçalho que os arquivos de código privado do módulo precisam acessar, mas não precisamos "importar" nem vincular.
$ PrivateDependencyModuleNames (List<String>): lista de nomes de módulos de dependência privada. Esses são módulos dos quais nosso código privado depende, mas dos quais os arquivos de inclusão públicos não dependem.
$ CircularlyReferencedDependentModules (List<String>): apenas para uso legado, não deve ser usado em um novo código. Lista de dependências de módulo que devem ser tratadas como referências circulares. Esses módulos já devem ter sido adicionados à lista de módulos dependentes públicos ou privados.
$ PublicSystemIncludePaths (List<String>): lista de caminhos de inclusão do sistema/biblioteca. Normalmente é usada para módulos externos (de terceiros). São diretórios públicos de arquivo de cabeçalho estáveis que não são verificados ao resolver dependências de cabeçalho.
$ PublicIncludePaths (List<String>): (esta configuração não é necessária no momento, pois encontramos todos os arquivos da pasta "Public"). A lista de todos os caminhos para incluir arquivos expostos a outros módulos
$ InternalIncludePaths (List<String>): (Esta configuração não é necessária no momento, pois encontramos todos os arquivos da pasta "Internal") a lista de todos os caminhos para incluir arquivos que estão expostos a outros módulos internos
$ PrivateIncludePaths (List<String>): lista de todos os caminhos para os arquivos de inclusão internos deste módulo, não exposta a outros módulos (pelo menos uma inclusão para o caminho "Private", mais se quisermos evitar caminhos relativos)
$ PublicSystemLibraryPaths (List<String>): lista de caminhos da biblioteca do sistema (arquivos de diretório .lib) - para módulos externos (de terceiros), use PublicAdditionalLibaries
$ PrivateRuntimeLibraryPaths (List<String>): lista de caminhos de pesquisa para bibliotecas em tempo de execução (por exemplo, arquivos .so)
$ PublicRuntimeLibraryPaths (List<String>): lista de caminhos de pesquisa para bibliotecas em tempo de execução (por exemplo, arquivos .so)
$ PublicAdditionalLibraries (List<String>): lista de bibliotecas adicionais (nomes dos arquivos .lib, inclusive a extensão) - normalmente usados para módulos externos (de terceiros)
$ PublicDebugVisualizerPaths (List<String>): a lista de visualizadores de depuração adicionais (.natvis e .natstepfilter) expostos a outros módulos, geralmente usados para módulos externos (de terceiros)
$ DependenciesToSkipPerArchitecture (Dictionary<String, List<UnrealArch>>): listas de dependências por arquitetura para vinculação a serem ignoradas (útil na compilação para várias arquiteturas, e só uma lib é necessária para uma arquitetura). Isso é para uso do conjunto de ferramentas
$ PublicPreBuildLibraries (List<String>): lista de bibliotecas pré-construídas adicionais (nomes dos arquivos .lib , inclusive a extensão) - normalmente usado para alvos adicionais que ainda são compilados, mas usando TargetRules.PreBuildSteps ou TargetRules.PreBuildTargets.
$ PublicSystemLibraries (List<String>): lista de bibliotecas do sistema a serem usadas. Geralmente são referenciadas pelo nome e, em seguida, encontradas pelos caminhos do sistema. Se precisar referenciar uma .lib, use o arquivo PublicAdditionalLibraries
$ PublicFrameworks (List<String>): lista de frameworks de Xcode (iOS e macOS)
$ PublicWeakFrameworks (List<String>): lista de frameworks fracos (para transições de versão do SO)
$ PublicAdditionalFrameworks (List<Framework>): lista de frameworks adicionais. Geralmente é usado para módulos externos (de terceiros) no Mac e iOS
$ AdditionalBundleResources (List<BundleResource>): lista de recursos adicionais que devem ser copiados ao pacote de app para Mac ou iOS.
$ TypeLibraries (List<TypeLibrary>): lista de bibliotecas de tipos para as quais precisamos gerar cabeçalhos (apenas para Windows)
$ PublicDelayLoadDLLs (List<String>): lista de DLLs de carregamento com atraso. Normalmente é usada para módulos externos (de terceiros)
$ PrivateDefinitions (List<String>): definições de compilador privado para este módulo
$ PublicDefinitions (List<String>): definições públicas do compilador para este módulo
$ DynamicallyLoadedModuleNames (List<String>): módulos de adição que este módulo pode exigir em tempo de execução
$ RuntimeDependencies (RuntimeDependencyList): lista de arquivos dos quais este módulo depende no tempo de execução. Esses arquivos serão organizados juntamente com o alvo.
$ AdditionalPropertiesForReceipt (ReceiptPropertyList): lista de propriedades adicionais a serem adicionadas ao comprovante de compilação
$ ExternalDependencies (List<String>): arquivos externos que invalidam o makefile se forem modificados. Os caminhos relativos são resolvidos em relação ao arquivo .build.cs.
$ SubclassRules (List<String>): arquivos de regras de subclasse que invalidam o makefile, se modificado.
$ GenerateHeaderFuncs (List<ValueTuple<string, Action<ILogger, DirectoryReference>>>): uma lista de nomes de subdiretórios e funções invocadas para gerar arquivos de cabeçalho. O nome do subdiretório é anexado ao diretório do código gerado para formar um diretório em que os cabeçalhos são gerados.
$ Name (String): nome deste módulo
$ Tipo (ModuleType): o tipo de módulo
$ OverridePackageType (PackageOverrideType): tipo de módulo substituído que definirá diferentes sinalizações de pacotes. Não pode ser usado para módulos que fazem parte de um plugin porque isso já está definido no arquivo ".uplugin".
$ BinariesSubFolder (string): a subpasta da pasta Binaries/PLATFORM onde este módulo deve ser colocado ao criar DLLs. Só deve ser usada por módulos que são encontrados por meio de pesquisa, como os módulos TargetPlatform ou ShaderFormat. Se FindModules não for usado para rastreá-los, os módulos não serão encontrados.
$ OptimizeCode (CodeOptimization): quando o código deste módulo deve ser otimizado.
$ OptimizationLevel (OptimizationMode): permite ajustar o nível de otimização para velocidade e/ou tamanho do código. Isso requer um PCH privado (ou NoPCHs, o que não é recomendado)
$ FPSemantics (FPSemanticsMode): permite sobrepor a semântica de FP para este módulo. Isso requer um PCH privado (ou NoPCHs, o que não é recomendado)
$ PrivatePCHHeaderFile (String): o PCH privado explícito para este módulo. Significa que este módulo não usará um PCH compartilhado.
$ SharedPCHHeaderFile (String): o nome do arquivo de cabeçalho para um PCH compartilhado fornecido por este módulo. Deve ser um caminho relativo válido para um arquivo de cabeçalho C++ público. Isso só deve ser definido para arquivos de cabeçalho incluídos por um número significativo de outros módulos C++.
$ ShortName (String): especifica um nome alternativo para diretórios e arquivos intermediários para intermediários deste módulo. Útil quando há limitações de tamanho do caminho.
$ PCHUsage (PCHUsageMode): uso de cabeçalho pré-compilado para este módulo
$ bTreatAsEngineModule (booleano): se este módulo deve ser tratado como um módulo da engine (por exemplo, ao usar definições da engine, PCHs, compiladas com otimizações habilitadas nas configurações de DebugGame etc.). Inicializado com um padrão baseado no conjunto de regras que serviu de base para a criação.
$ bValidateFormatStrings (booleano): emite erros de compilação para strings de formato UE_LOG incorretas.
$ bValidateInternalApi (booleano): emite avisos/erros de conteúdo descontinuado para uso interno da API para módulos que não são da engine
$ DefaultBuildSettings (BuildSettingsVersion): as configurações de compilação a serem usadas como padrão.
$ IncludeOrderVersion (EngineIncludeOrderVersion): qual versão do pedido de inclusão usar ao compilar este módulo. Pode ser substituída usando -ForceIncludeOrder na linha de comando ou nas regras do módulo.
$ bUseRTTI (booleano): usa informações de tipo de tempo de execução
$ bVcRemoveUnreferencedComdat (booleano): determina se o MSVC deve remover funções e dados COMDAT não referenciados.
$ bCodeCoverage (booleano): ativa suporte para a compilação/vinculação de cobertura de código.
$ bUseAVX (booleano): obsoleto: instrui o compilador que gere instruções AVX sempre que forem usados intrínsecos SSE ou AVX em plataformas com suporte. Observe que, ao habilitar essa opção, você está alterando o minspec para a plataforma de PC, e o executável resultante falhará em máquinas sem suporte para AVX.
$ MinCpuArchX64 (Nullable<MinimumCpuArchitectureX64>): direciona o compilador para gerar instruções AVX sempre que forem usados intrínsecos SSE ou AVX em plataformas x64 com suporte. Observe que, ao habilitar essa opção, você está alterando o minspec para a plataforma de PC, e o executável resultante falhará em máquinas sem suporte para AVX.
$ bEnableBufferSecurityChecks (booleano): habilita verificações de segurança do buffer. Isso geralmente deve ser habilitado, pois evita riscos graves para a segurança.
$ bEnableExceções (booleano): habilita o tratamento de exceções
$ bEnableObjCExceptions (booleano): habilita o tratamento de exceções do objetivo C
$ bEnableObjCAutomaticReferenceCounting (booleano): habilita a contagem automática de referência (ARC) do objetivo C. Se você definir essa opção como verdadeira, não deverá usar PCHs compartilhados para este módulo. A engine não usará muito o ARC no curto prazo. Não fazer isso resultará em erros de compilação, pois os PCHs compartilhados foram compilados com sinalizações diferentes das do consumidor.
$ DeterministicWarningLevel (WarningLevel): como tratar avisos determinísticos (experimental).
$ ShadowVariableWarningLevel (WarningLevel): como tratar avisos de variável de sombra
$ bWarningsAsErrors (booleano): determina se todos os avisos devem ser habilitados como erros. A UE já habilita a maioria dos avisos como erros, mas desabilita alguns (como avisos de depreciação).
$ UnsafeTypeCastWarningLevel (WarningLevel): como tratar avisos de conversão de tipo implícita insegura (por exemplo, double->float ou int64->int32)
$ UndefinedIdentifierWarningLevel (WarningLevel): indica o nível de aviso/erro para tratar identificadores indefinidos em expressões condicionais.
$ bEnableUndefinedIdentifierWarnings (booleano): ativa avisos para usar identificadores indefinidos em expressões #if
$ ModuleIncludePathWarningLevel (WarningLevel): como tratar as mensagens de validação do caminho de inclusão do módulo geral
$ ModuleIncludePrivateWarningLevel (WarningLevel): como tratar as mensagens de validação de caminho de inclusão de módulo privado, em que um módulo está adicionando um caminho de inclusão que expõe cabeçalhos privados
$ ModuleIncludeSubdirectoryWarningLevel (WarningLevel): como tratar mensagens desnecessárias de validação de caminho de inclusão de subdiretório de módulo
$ bDisableStaticAnalysis (booleano): desabilita todas as análises estáticas: clang, msvc, pvs-studio.
$ bStaticAnalyzerExtensions (booleano): habilita avisos adicionais de extensão do analisador usando o plugin EspXEngine. Isso apenas é compatível com o MSVC. Confira https://learn.microsoft.com/pt-br/cpp/code-quality/using-the-cpp-core-guidelines-checkers Isso adicionará um grande número de avisos por padrão. É recomendado usar StaticAnalyzerRulesets se isto estiver ativado.
$ bUseUnity (booleano): se as versões do Unity estiverem habilitadas, poderá ser usado como substituição se este módulo específico for compilado usando Unity. Isso é definido usando as configurações por módulo em BuildConfiguration.
$ bMergeUnityFiles (booleano): determina se os arquivos do Unity gerados e do módulo devem ser mesclados para serem compilados mais rapidamente.
$ MinSourceFilesForUnityBuildOverride (Int32): o número de arquivos de origem neste módulo antes que a compilação do Unity seja ativada para esse módulo. Se definida como um valor diferente de -1, irá substituir a configuração padrão controlada por MinGameModuleSourceFilesForUnityBuild
$ MinFilesUsingPrecompiledHeaderOverride (Int32): substitui BuildConfiguration.MinFilesUsingPrecompiledHeader se for diferente de zero.
$ NumIncludedBytesPerUnityCPPOverride (Int32): substitui Target.NumIncludedBytesPerUnityCPP se for diferente de zero.
$ bBuildLocallyWithSNDBS (booleano): o módulo usa um #import, por isso deve ser criado localmente durante a compilação com SN-DBS
$ bEnableNonInlinedGenCppWarnings (booleano): habilita avisos para quando houver arquivos .gen.cpp que possam ser embutidos em um arquivo cpp escrito à mão correspondente
$ IsRedistributableOverride (Nullable<Boolean>): o sinalizador de substituição de redistribuição para este módulo.
$ bLegalToDistributeObjectCode (booleano): determina se a saída desse módulo pode ser distribuída publicamente, mesmo que tenha código/dependências em módulos que não sejam (ou seja, CarefullyRedist, NotForLicensees, NoRedist). Use essa opção quando planejar publicar binários, mas não o código-fonte.
$ bEnforceIWYU (booleano): aplica regras "incluir o que você usa" quando PCHUsage está definido como ExplicitOrSharedPCH; avisa quando cabeçalhos monolíticos (Engine.h, UnrealEd.h etc.) são usados e verifica se os arquivos de origem incluem primeiro o cabeçalho correspondente.
$ IWYUSupport (IWYUSupport): permite "incluir o que você usa" para modificar o código-fonte na execução. bEnforceIWYU deve ser verdadeiro para que esta variável funcione.
$ bAddDefaultIncludePaths (booleano): determina se todos os caminhos padrão de inclusão devem ser adicionados ao módulo (por exemplo, na pasta Source/Classes, subpastas em Source/Public).
$ bIgnoreUnresolvedSymbols (booleano): determina se símbolos pendentes (por exemplo, externos não resolvidos) devem ser ignorados em módulos
$ bPrecompile (booleano): determina se este módulo deve ser pré-compilado. O padrão é o sinalizador bPrecompile do alvo. Remova esse sinalizador para evitar que um módulo seja pré-compilado.
$ bUsePrecompiled (booleano): determina se o módulo deve usar dados pré-compilados. Sempre verdadeiro para módulos criados com base em conjuntos instalados.
$ bAllowConfidentialPlatformDefines (booleano): determina se este módulo pode usar definições do estilo PLATFORM_XXXX, em que XXXX é um nome de plataforma confidencial. Usado para garantir que a engine ou outro código compartilhado não revelará informações confidenciais dentro de um bloco #if da PLATFORM_XXXX. No entanto, o código do jogo licenciado pode querer permitir isso.
$ bDisableAutoRTFMInstrumentation (booleano): desabilita a instrumentação de AutoRTFM para este módulo somente quando AutoRTFMCompiler está habilitado
$ PrecompileForTargets (PrecompileTargetsType): para quais destinos este módulo deve ser pré-compilado
$ bRequiresImplementModule (Nullable<Boolean>): determina se o módulo exige a implementação do macro IMmplement_MODULE. A maioria dos módulos da UE exige isso, pois usamos o macro IMmplement_MODULE para fazer outras sobrecargas globais (por exemplo, operador novo/excluir encaminhamento para GMalloc).
$ bLegacyPublicIncludePaths (booleano): se este módulo qualifica cabeçalhos incluídos de outros módulos em relação à raiz da pasta "Public" deles. Isso reduz o número de caminhos de pesquisa que precisam ser passados ao compilador, melhorando o desempenho e reduzindo o tamanho da linha de comando dele.
$ bLegacyParentIncludePaths (booleano): se este módulo qualifica cabeçalhos incluídos de outros módulos relativos ao diretório-pai. Isso reduz o número de caminhos de pesquisa que precisam ser passados ao compilador, melhorando o desempenho e reduzindo o tamanho da linha de comando dele.
$ bValidateCircularDependencies (booleano): determina se as dependências circulares serão validadas na lista de permissões. As dependências de módulo circulares resultam em compilações mais lentas. Desativar esta opção não é recomendado. Esta opção é ignorada para módulos da engine, que sempre serão validados na lista de permissões.
$ CppStandard (Nullable<CppStandardVersion>): qual padrão usar para compilar este módulo
$ CStandard (Nullable<CStandardVersion>): aual padrão usar para compilar este módulo
$ ModuleSymbolVisibility (SymbolVisibility): controla a visibilidade dos símbolos