Destinos

A **Unreal Build Tool (UBT)** permite a criação de vários tipos de destino:

• Game: um jogo independente que requer dados preparados para rodar.

• Cliente: igual a Game, mas não inclui código de servidor. Útil para jogos em rede.

• Servidor: igual a Game, mas não inclui código de cliente. Útil para servidores dedicados em jogos em rede.

• Editor: um destino que amplia o Unreal Editor.

• Programa: um programa utilitário independente desenvolvido na Unreal Engine.

Os destinos são declarados por arquivos de código-fonte C# com extensão .target.cs e armazenados no diretório-raiz do projeto. O arquivo .target.cs declara uma classe derivada da classe-base TargetRules e define propriedades para controlar como ela deve ser construída com base no seu constructor. Quando a compilação for solicitada para um destino, a Unreal Build Tool compilará o arquivo .target.cs e construirá a classe dentro dele para determinar suas configurações.

O nome da classe deve corresponder ao nome do arquivo em que ela foi declarada, seguido de "Target" (por exemplo, MyProject.target.cs define a classe MyProjectTarget).

A estrutura típica para um arquivo de destino é a seguinte:

using UnrealBuildTool;
	using System.Collections.Generic;
	public class MyProjectTarget : TargetRules
	{
		public MyProjectTarget(TargetInfo Target) : base(Target)
		{
			Type = TargetType.Game;
			// Other properties go here
		}
	}

Propriedades somente leitura

$ OriginalName (string): retorna o nome do destino original sem substituições nem adornos

$ IsTestTarget (booleano): indica se é um destino de teste de baixo nível.

$ ExplicitTestsTarget (booleano): indica se é um destino de teste definido explicitamente. Destinos de teste definidos explicitamente sempre herdam de TestTargetRules e definem os próprios testes. Destinos de teste implícitos são criados com base em destinos existentes ao compilar com -Mode=Test e incluem testes de todas as dependências.

$ WithLowLevelTests (booleano): controla o valor de WITH_LOW_LEVEL_TESTS que determina se os testes de baixo nível específicos do módulo são compilados ou não.

$ Architecture (UnrealArch): obtém a arquitetura no caso normal em que há uma única arquitetura em Architectures (isso gera uma exceção se houver mais que uma arquitetura especificada)

$ bIWYU (booleano): habilita "incluir o que você usa" por padrão para módulos neste destino. Altera o modo do PCH padrão de qualquer módulo neste projeto para PCHUsageMode.UseExplicitOrSharedPCHs.

$ DisableDebugInfoModules (HashSet<String>): módulos que devem ter as informações de depuração desabilitadas

$ DisableDebugInfoPlugins (HashSet<String>): plugins que devem ter as informações de depuração desabilitadas

$ DebugInfoLineTablesOnlyModules (HashSet<String>): os módulos que devem emitir tabelas de números em linha em vez de informações de depuração completas para compiladores com suporte para isso. Substitui DisableDebugInfoModules

$ DebugInfoLineTablesOnlyPlugins (HashSet<String>): plugins que devem emitir tabelas de números em linhas em vez de informações de depuração completas para compiladores com suporte para isso. Substitui DisableDebugInfoPlugins

$ MergePlugins (List<String>): Experimental: lista de plugins (e suas dependências) para mesclagem em bibliotecas separadas. Requer que bMergeModules esteja habilitado

$ MergePluginsShared (Dictionary<string, HashSet<String>>): Experimental: lista de plugins combinados para mover dependências comuns para uma biblioteca compartilhada. Requer MergePlugins. Pode ser encadeado

$ MergePluginsLaunch (List<String>): Experimental: lista de plugins combinados a serem movidos para o executável principal, requer MergePlugins. "Engine" para todos os módulos compartilhados da engine e "Common" para os módulos compartilhados do projeto.

$ GlobalDefinitions (List<String>): macros a serem definidos globalmente em todo o destino.

$ ProjectDefinitions (List<String>): macros a serem definidos em todos os macros do projeto.

$ ExtraModuleNames (List<String>): lista de módulos adicionais a serem compilados no destino.

$ ManifestFileNames (List<FileReference>): caminho para um manifesto de saída para este destino

$ DependencyListFileNames (List<FileReference>): caminho para uma lista de dependências desse destino durante a pré-compilação

$ PreBuildTargets (List<TargetInfo>): especifica uma lista de destinos que devem ser compilados antes do destino.

$ PreBuildSteps (List<String>): especifica uma lista de etapas que devem ser executadas antes da compilação desse destino, no contexto do shell da plataforma do host. As seguintes variáveis serão expandidas antes da execução: $(EngineDir), $(ProjectDir), $(TargetName), $(TargetPlatform), $(TargetConfiguration), $(TargetType), $(ProjectFile).

$ PostBuildSteps (List<String>): especifica uma lista de etapas que devem ser executadas após a compilação desse destino, no contexto do shell da plataforma do host. As seguintes variáveis serão expandidas antes da execução: $(EngineDir), $(ProjectDir), $(TargetName), $(TargetPlatform), $(TargetConfiguration), $(TargetType), $(ProjectFile).

$ AdditionalBuildProducts (List<String>): especifica produtos de compilação adicionais gerados como parte deste destino.

$ HostPlatform (UnrealTargetPlatform): obtém a plataforma do host que está sendo construída

$ bGenerateProjectFiles (booleano): expõe o sinalizador bGenerateProjectFiles aos destinos para que possamos modificar o comportamento conforme apropriado para obter um intellisense melhor

$ bShouldTargetRulesTogglePlugins (booleano): indica se as regras de destino devem ser usadas para habilitar ou desabilitar plugins de forma explícita. Geralmente não é necessário para a geração de projetos, a menos que os arquivos do projeto indiquem se os plugins referenciados devem ser compilados ou não.

$ bIsEngineInstalled (booleano): expõe uma configuração para a engine estar ou não instalada

Propriedades de gravação/leitura

$ BuildPlugins (List<String>): plugins adicionais criados para este tipo de destino, mas não habilitados.

$ AdditionalPlugins (List<String>): uma lista de plugins adicionais que precisam ser incluídos neste destino. Isso permite a referência de módulos de plugin não opcionais que não podem ser desabilitados e permite a compilação com módulos específicos em destinos do programa que não se encaixam nas categorias de ModuleHostType.

$ EnablePlugins (List<String>): plugins adicionais que devem ser incluídos para este destino.

$ DisablePlugins (List<String>): lista de plugins a serem desabilitados para este destino. Observe que o arquivo do projeto ainda pode referenciá-los. Por isso, devem ser marcados como opcionais para evitar falhas em tempo de execução.

$ optionalPlugins (List<String>): plugins adicionais que devem ser incluídos para este destino, se encontrados.

$ InternalPluginDependencies (List<String>): uma lista de nomes de plugins que são permitidos existir como dependências sem serem definidos no descritor uplugin

$ DisableMergingModuleAndGeneratedFilesInUnityFiles (String[]): a lista de módulos que desabilita a fusão do módulo e dos arquivos cpp gerados nos mesmos arquivos unity.

$ bShowIncludes (booleano): imprime os arquivos que são incluídos por cada arquivo de origem

$ DisableUnityBuildForModules (String[]): lista de módulos para os quais desabilitar compilações do Unity

$ EnableOptimizeCodeForModules (String[]): lista de módulos para os quais habilitar otimizações

$ DisableOptimizeCodeForModules (String[]): lista de módulos para os quais desabilitar otimizações

$ OptimizeForSizeModules (String[]): lista de módulos a serem otimizados quanto ao tamanho. Isso permite que o destino substitua o nível de otimização do módulo. Observe que isso pode desabilitar o uso de PCH se um PCH privado não for fornecido

$ OptimizeForSizeAndSpeedModules (String[]): lista de módulos a serem otimizados quanto ao tamanho e à velocidade. Isso permite que o destino substitua o nível de otimização do módulo. Observe que isso pode desabilitar o uso de PCH se um PCH privado não for fornecido

$ OptedInModulePlatforms (UnrealTargetPlatform[]): se isto não for nulo, as plataformas NÃO listadas não terão permissão para ter módulos criados em seus diretórios

$ Name (string): o nome do destino

$ Logger (ILogger): o registrador para a saída relacionada a esse destino. Definido antes da execução do constructor

$ AdditionalData (object): um objeto genérico que permite valor nulo para que o usuário possa definir dados adicionais em uma TargetRule do projeto e acessar em uma ModuleRule do projeto sem precisar adicionar novas propriedades pós-publicação. Por exemplo:

* in .Target.cs: AdditionalData = "data";

* in .Build.cs: if ((Target.AdditionalData as string) == "data") { ... }

$ Plataform (UnrealTargetPlatform): a plataforma para a qual este destino está sendo criado.

$ Configuration (UnrealTargetConfiguration): a configuração que está sendo criada.

$ Architectures (UnrealArchitectures): a arquitetura para a qual o destino foi criado (ou uma string vazia para o padrão).

$ IntermediateEnvironment (UnrealIntermediateEnvironment): ambiente intermediário. Determina se os intermediários vão para uma pasta diferente da normal.

$ ProjectFile (FileReference): o caminho para o arquivo do projeto que contém este destino.

$ Version (ReadOnlyBuildVersion): a versão da compilação atual

$ tipo (TargetType): o tipo do destino.

$ DefaultBuildSettings (BuildSettingsVersion): especifica a versão da engine com a qual manter as configurações padrão de compilação compatíveis com versões anteriores (por exemplo, DefaultSettingsVersion.Release_4_23, DefaultSettingsVersion.Release_4_24). Especifique DefaultSettingsVersion.Latest para sempre usar padrões para a versão atual da engine, sob o risco de introduzir erros de compilação durante a atualização.

$ ForcedIncludeOrder (Nullable<EngineIncludeOrderVersion>): força a ordem de inclusão a uma versão específica. Substitui regras de destino e módulo.

$ IncludeOrderVersion (EngineIncludeOrderVersion): qual versão do pedido de inclusão será usada ao compilar este destino. Pode ser substituída usando -ForceIncludeOrder na linha de comando. ModuleRules.IncludeOrderVersion tem precedência.

$ OutputFile (String): caminho para o arquivo de saída do executável principal, relativo à engine ou ao diretório do projeto. Essa configuração geralmente só é útil para programas que não são da UE, pois a engine usa caminhos relativos ao executável para encontrar outras pastas conhecidas (por exemplo, Content).

$ bUsesSteam (booleano): se o destino usa o Steam.

$ bUsesCEF3 (booleano): se o destino usa CEF3.

$ bUsesSlate (booleano): indica se o projeto usa a interface Slate (em vez de janelas/mensagens de baixo nível, que estão sempre disponíveis).

$ bUseStaticCRT (booleano): força a vinculação no CRT estático. Essa funcionalidade não é totalmente suportada para a engine devido à necessidade do compartilhamento de implementações de alocadores (por exemplo) e da consistência entre as bibliotecas de STP. No entanto, ela pode ser usada para programas utilitários.

$ bDebugBuildsActuallyUseDebugCRT (booleano): habilita o tempo de execução C++ (CRT) para compilações de depuração. Por padrão, sempre usamos o tempo de execução da versão de lançamento, pois a versão de depuração não é particularmente útil na depuração de projetos da Unreal Engine, e a vinculação com as bibliotecas CRT de depuração força nossas dependências de bibliotecas de terceiros a também serem compiladas usando a CRT de depuração (e, muitas vezes, com desempenho mais lento). Muitas vezes, pode ser inconveniente exigir uma cópia separada das versões de depuração de bibliotecas estáticas de terceiros simplesmente para que você possa depurar o código do seu programa.

$ bLegalToDistributeBinary (booleano): Se a saída desse destino pode ser distribuída publicamente, mesmo que tenha dependências de módulos que estejam em pastas com restrições especiais (por exemplo: CarefullyRedist, NotForLicensees, NoRedist).

$ UndecoratedConfiguration (UnrealTargetConfiguration): especifica a configuração cujos binários não exigem o sufixo "-Plataform-Configuration".

$ DecoratedSeparator (String): especifica o caractere separador para nomes de arquivos binários.

$ bAllowHotReload (booleano): se o destino é compatível com recarga dinâmica

$ bBuildAllModules (booleano): cria todos os módulos válidos para esse tipo de destino. Usado para CIS e criação de versões instaladas na engine.

$ VSTestRunSettingsFile (FileReference): conjunto para referenciar um arquivo de configurações de execução de VSTest dos projetos gerados.

$ bRuntimeDependenciesComeFromBuildPlugins (booleano): se for verdadeiro, a lista BuildPlugins será usada para preencher RuntimeDependencies em vez de EnablePlugins

$ bAllowEnginePluginsEnabledByDefault (booleano): se falso, suprime o carregamento de plugins da engine "habilitados por padrão" não habilitados explicitamente pelo projeto ou arquivos de destino.

$ DisablePluginsConflictWarningLevel (WarningLevel): como tratar conflitos quando um plugin desabilitado está sendo habilitado por outro plugin que o referencia

$ PakSigningKeysFile (string): caminho para o conjunto de chaves de assinatura pak a serem embutidas no executável.

$ SolutionDirectory (string): permite que o destino de um programa especifique o caminho da sua própria pasta de solução.

$ bGenerateProgramProject (booleano): força um alvo a ser tratado como um programa para fins de geração de arquivo de projeto.

$ bExplicitTargetForType (booleano): se for verdadeiro, GetTargetNameByType não considerará esse destino, removendo a ambiguidade de -TargetType=X.

$ bBuildInSolutionByDefault<Boolean>(Nullable): determina se o destino deve ser incluído na configuração padrão da compilação da solução. Definir como falso ignora a criação durante a execução na IDE

$ bShouldCompileAsDLL (booleano): determina se o destino deve ser compilado como uma DLL. Exige que LinkType seja definido como TargetLinkType.Monolithic.

$ CustomConfig (string): o subdiretório extra para carregar arquivos de configuração, de modo a criar vários tipos de compilação com a mesma plataforma. Isso será incorporado ao executável do jogo como CUSTOM_CONFIG e usado na preparação para filtrar arquivos e configurações

$ ExeBinariesSubFolder (string): subpasta onde os executáveis serão inseridos em relação ao posição padrão.

$ GeneratedCodeVersion (EGeneratedCodeVersion): permite que o módulo de destino substitua a versão de geração de código UHT.

$ bEnableMeshEditor (booleano): determina se o editor de malha deve ser habilitado.

$ bUseVerseBPVM (booleano): determina se o BPVM será usado para executar o Verse.

$ bUseAutoRTFMCompiler (booleano): determina se o compilador Clang AutoRTFM deve ser usado.

$ bForceNoAutoRTFMCompiler (booleano): determina se o compilador Clang AutoRTFM desativado deve ser usado.

$ bUseAutoRTFMVerifier (booleano): determina se a emissão de metadados de verificação AutoRTFM deve ser habilitada

$ bCompileChaos (booleano): determina se o plugin de física do Chaos deve ser compilado.

$ bUseChaos (booleano): determina se a interface de física do Chaos será usada. Isso substitui os sinalizadores de physx para desabilitar APEX e NvCloth

$ bUseChaosChecked (booleano): determina se as funcionalidades do Chaos verificadas para depuração serão compiladas

$ bUseChaosMemoryTracking (booleano): determina se as funcionalidades de rastreamento de memória do Chaos serão compiladas

$ bCompileChaosVisualDebuggerSupport (booleano): determina se os recursos de suporte do depurador visual do Chaos (CVD) devem ser compilados para registrar o estado da simulação de física

$ bCustomSceneQueryStructure (booleano): se a aceleração de consulta de cena é feita pela UE. A estrutura de consulta de cena de physx ainda é criada, mas não a usamos.

$ bCompilePhysX (booleano): se deve incluir suporte para PhysX.

$ bCompileAPEX (booleano): determina se deve incluir o suporte para PhysX APEX.

$ bCompileNvCloth (booleano): determina se NvCloth deve ser incluído.

$ bCompileICU (booleano): determina se o suporte a Unicode/i18n de ICU deve ser incluído no Core.

$ bCompileCEF3 (booleano): determina se a compilação será compatível com CEF3.

$ bCompileISPC (booleano): compila com o ISPC.

$ bCompileIntelMetricsDiscovery (booleano): determina se IntelMetricsDiscovery será compilado.

$ bCompilePython (booleano): se a compilação será compatível com python

$ bUseGameplayDebugger (booleano): se a compilação será feita com WITH_GAMEPLAY_DEBUGGER habilitado com todas as categorias de depurador de jogabilidade padrão da Engine.

$ bUseGameplayDebuggerCore (booleano): define como verdadeiro quando bUseGameplayDebugger for falso, mas as partes principais do GameplayDebugger forem necessárias.

$ bCompileIoStoreOnDemand (booleano): determina se o armazenamento de E/S sob demanda deve ser usado

$ bUseIris (booleano): determina se o Iris deve ser usado.

$ bTrackRHIResourceInfoForTest (booleano): determina se o proprietário (nome do ativo) do recurso RHI deve ser rastreado para configuração de teste. Útil para comandos ListShaderMaps e ListShaderLibraries.

$ bBuildEditor (booleano): determina se estamos compilando o código do editor. Prefira o bCompileAgainstEditor mais explícito.

$ bBuildRequiresCookedData (booleano): determina se o código relacionado à compilação de ativos deve ser compilado. Geralmente os consoles não compilam ativos. Em geral, as plataformas de desktop, sim.

$ bBuildWithEditorOnlyData (booleano): determina se a compilação com WITH_EDITORONLY_DATA está desabilitada. Apenas o Windows usará isso, outras plataformas forçam essa opção para falso.

$ bBuildDeveloperTools (booleano): determina se as ferramentas de desenvolvedor devem ser compiladas.

$ bBuildTargetDeveloperTools (booleano): determina se deve compilar as ferramentas de desenvolvedor para plataformas de destino ou dispositivos conectados (o valor padrão é bBuildDeveloperTools)

$ bForceBuildTargetPlatforms (booleano): determina se a compilação forçada dos módulos das plataformas de destino deve ser forçada, mesmo que eles não sejam normalmente compilados.

$ bForceBuildShaderFormats (booleano): determina se deve forçar a compilação de módulos de formato de shader, mesmo que eles não sejam compilados.

$ bNeedsExtraShaderFormatsOverride<Boolean>(Nullable): substitui para incluir formatos de shader adicionais

$ bNeedsExtraShaderFormats (booleano): determina se devemos incluir formatos adicionais de shader. Por padrão, essa opção só está habilitada para destinos de programa e editor.

$ bCompileCustomSqlitePlatform (booleano): define se devemos compilar o Sqlite usando a plataforma da Unreal personalizada (verdadeiro) ou a plataforma nativa (falso).

$ bUseCacheFreedOSAllocs (booleano ): determina se serão utilizados alocações de SO de cache livres com MallocBinned

$ bCompileAgainstEngine (booleano): habilitada para todas as versões que incluem o projeto da engine. Desabilitada apenas na criação de aplicativos independentes que se vinculam apenas ao Core.

$ bCompileAgainstCoreUObject (booleano): habilitado para todas as versões que incluem o projeto CoreUObject. Desabilitada apenas na criação de aplicativos independentes que se vinculam apenas ao Core.

$ bCompileAgainstApplicationCore (booleano): habilitado para versões que precisam inicializar o módulo ApplicationCore. Em geral, utilitários de linha de comando não precisam disso.

$ bEnableTrace (booleano): habilitada para versões que desejam ser usadas com base no módulo Trace para realizar análises e diagnóstico.

$ bForceEnableTrace (booleano): força de habilitação do traçado. É usada para permitir que os programas de teste verifiquem se o traçado funciona conforme o esperado.

$ bCompileAgainstEditor (booleano): habilitado para versões do editor (TargetType.Editor). Pode ser substituído por programas (TargetType.programa) que precisam ser compilados com base em um código de editor. Não disponível para outros tipos de destino. Aciona principalmente o valor de WITH_EDITOR.

$ bCompileRecast (booleano): determina se a geração de NavMesh de reformulação será compilada.

$ bCompileNavmeshSegmentLinks (booleano): determina se os links de segmentos de NavMesh serão compilados.

$ bCompileNavmeshClusterLinks (booleano): determina se os links de clusters de NavMesh serão compilados.

$ bCompileSpeedTree (booleano): determina se devemos compilar de modo a ter compatibilidade com a SpeedTree.

$ bForceEnableceptions (booleano): habilita exceções para todos os módulos.

$ bUseInlining (Booleano): habilita a inclusão em linha para todos os módulos.

$ bForceEnableObjCceptions (booleano): habilita exceções para todos os módulos.

$ bForceEnableRTTI (booleano): habilita o RTTI para todos os módulos.

$ bEnablePrivateBuildInformation (booleano): habilita BuildSettings para conter informações privadas sobre a compilação. Igual ao nome da máquina, o nome do usuário e o nome do domínio do usuário (exposto em BuildSettings.h)

$ bEnablePIE (booleano): habilita o executável independente da posição (JNE). Tem um custo indireto

$ bEnableStackProtection (booleano): habilita a proteção de pilha. Tem um custo indireto

$ bWithClientCode (booleano): compila o código somente do cliente.

$ bWithServerCode (booleano): compila o código somente do servidor.

$ bFNameOutlineNumber (booleano): compila com FName e armazena a parte numérica na tabela de nomes. Economiza memória quando a maioria dos nomes não for numerada e os que são forem referência várias vezes. O jogo e a engine deverão garantir que eles reutilizarão os nomes numerados de forma semelhante a strings para evitar vazamento de memória.

$ bWithPushModel (booleano): quando habilitada, a compatibilidade com rede de modelo push será compilada. Isso pode ajudar a reduzir a sobrecarga de rede para a CPU, à custa de mais memória. Sempre ativado nas compilações do editor.

$ bCompileWithStatsWithoutEngine (booleano): determina se é necessário incluir estatísticas mesmo sem a engine.

$ bCompileWithPluginSupport (booleano): determina se deve incluir compatibilidade com plugin.

$ bIncludePluginsForTargetPlatforms (booleano): determina se deve permitir plugins compatíveis com todas as plataformas de destino.

$ bCompileWithAccessibilitySupport (booleano): determina se o código de acessibilidade é permitido no Slate e na camada do SO.

$ bWithPerfCounters (booleano): determina se deve incluir o suporte para PerfCounters.

$ bWithLiveCoding (booleano): determina se o suporte para codificação em tempo real deve ser habilitado

$ bUseDebugLiveCodingConsole (booleano): determina se o suporte para codificação em tempo real deve ser habilitado

$ bWithDirectXMath (booleano): determina se o suporte para DirectX Math deve ser habilitado. LWC_TODO: não é mais suportado. Precisa ser removido.

$ bWithFixedTimeStepSupport (booleano): determina se deve habilitar o suporte para FixedTimeStep na engine.

$ bUseLoggingInShipping (booleano): determina se deve ser ativado o registro para versões de teste/lançamento.

$ bUseConsoleInShipping (booleano): determina se o console deve ser ativado para versões de lançamento.

$ bLoggingToMemoryEnabled (booleano): determina se deve ser ativado o registro na memória para versões de teste/lançamento.

$ bUseLauncherChecks (booleano): determina se deve ser verificado se o processo foi inicializado por um inicializador externo.

$ bUseChecksInShipping (booleano): determina se as verificações (asserts) devem ser ativadas para versões de teste/lançamento.

$ bAllowProfileGPUINTest (booleano): determina se os marcadores de GPU devem ser ativados para versões de teste.

$ bAllowProfileGPUInShipping (booleano): determina se os marcadores de GPU devem ser ativados para versões de lançamento.

$ bTCHARIsUTF8 (booleano): determina se o modo UTF-8 deve ser ativado, mapeando TCHAR para UTF8CHAR.

$ bUseEstimatedUtcnow (booleano): determina se será usado EstimatedUtcnow ou PlatformUtcnow. EstimatedUtc Now é útil nos casos em que PlatformUtc Now pode ser lento.

$ bCompileFreeType (booleano): verdadeiro se precisarmos do suporte para FreeType.

$ bUseExecCommandsInShipping (booleano): determina se a permissão para comandos de execução é habilitada para compilações de envio.

$ bCompileForSize (booleano): verdadeiro se quisermos otimizar o tamanho em vez da velocidade.

$ OptimizationLevel (OptimizationMode): permite refinar o nível de otimizações para velocidade e/ou tamanho do código

$ FPSemantics (FPSemanticsMode): permite configurar a semântica do FP.

$ bForceCompileDevelopmentAutomationTests (booleano): determina se os testes automatizados de desenvolvimento serão compilados.

$ bForceCompilePerformanceAutomationTests (booleano): determina se os testes de automatização de desempenho devem ser compilados.

$ bForceDisableAutomationTests (booleano): determina se os padrões para testes automatizados (configurações de depuração/desenvolvimento) devem ser substituídos

$ bEventDrivenLoader (booleano): se verdadeiro, o carregador orientado a eventos será usado em compilações preparadas. @todoio Isso precisa ser substituído por uma solução de tempo de execução após a otimizar do carregamento assíncrono.

$ NativePointerMemberBehaviorOverride (Nullable<PointerMemberBehavior>): usado para substituir o comportamento que controla se UCLASSes e USTRUCTs têm permissão para ter membros de ponteiro nativos. Se essa permissão for desabilitada, serão considerados um erro UHT e deverão ser substituídos por membros TObjectPtr.

$ bUseXGEController (booleano): determina se o controlador de trabalho e os módulos XGE devem ser incluídos na compilação da engine. Eles são necessários para a compilação distribuída de sombreadores usando a interface de interceptação XGE.

$ bIncludeHeaders (booleano): adiciona arquivos de cabeçalho dos módulos incluídos à compilação.

$ bHeadersOnly (booleano): quando usado com -IncludeHeaders, apenas arquivos de cabeçalho serão compilados.

$ bEnforceIWYU (booleano): aplica regras "incluir o que você usa"; avisa se 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.

$ bWarnAboutMonolithicHeadersIncluded (booleano): emite um aviso quando um cabeçalho monolítico de estilo antigo é incluído durante a compilando desse destino.

$ bHasExports (booleano): determina se o executável final deve exportar símbolos.

$ bPrecompile (booleano): cria bibliotecas estáticas para todos os módulos da engine como intermediárias para esse destino.

$ bEnableOSX109Support (booleano): determina se deve ser compilado com suporte para OS X 10.9 Mavericks. Usado para algumas ferramentas que precisam ser compatíveis com esta versão do OS X.

$ bIsBuildingConsoleApplication (booleano): verdadeiro se for um aplicativo de console sendo compilado.

$ bBuildAdditionalConsoleApp (booleano): se verdadeiro, cria um aplicativo de console adicional. Truque para o Windows: onde não for possível herdar condicionalmente a janela de console dos pais dependendo de como o aplicativo for invocado, é preciso vincular o mesmo executável com uma configuração de subsistema diferente.

$ bBuildConsoleAppOnly (booleano ): se verdadeiro, cria apenas um aplicativo de console adicional. Substitui bBuildAdditionalConsoleApp.

$ bDisableSymbolCache (booleano): verdadeiro se não for necessário criar símbolos de depuração armazenados em cache para algumas plataformas.

$ bUseUnityBuild (booleano): determina se o código C++ deve ser unificado em arquivos maiores para acelerar a compilação.

$ bForceUnityBuild (booleano): determina se a combinação de arquivos de origem C++ deve ser forçada em arquivos maiores para acelerar a compilação.

$ bMergeModuleAndGeneratedUnityFiles (booleano): determina se o módulo e os arquivos do Unity devem ser mesclados para acelerar a compilação.

$ bUseAdaptiveUnityBuild (booleano): usa heurística para determinar quais arquivos estão sendo iterados no momento e exclui-os dos blobs d Unity, resultando em tempos de compilação incremental mais rápidos. A implementação atual usa o sinalizador somente leitura para diferenciar o conjunto de trabalho, presumindo que os arquivos poderão ser gravados pelo sistema de controle de origem se estiverem sendo modificados. Isso é válido para o Perforce, mas não para o Git.

$ bAdaptiveUnityDisablesOptimizations (booleano): desabilita a otimização dos arquivos que estão no conjunto de trabalho adaptativo que não é do Unity.

$ bAdaptiveUnityDisablesPCH (booleano): desativa a inclusão forçada de PCHs para arquivos que estão no conjunto de trabalho adaptativo que não é do Unity.

$ bAdaptiveUnityDisablesProjectPCHForProjectPrivate (Nullable<Boolean>): armazenamento de backup para bAdaptiveUnityDisablesProjectPCH.

$ bAdaptiveUnityDisablesPCHForProject (booleano): determina se a inclusão forçada de PCHs deve ser desabilitada para arquivos de origem do projeto no conjunto de trabalho adaptativo que não é do Unity. O valor padrão é bAdaptiveUnityDisablesPCH;

$ bAdaptiveUnityCreatesDedicatedPCH (booleano): cria um PCH dedicado para cada arquivo de origem no conjunto de trabalho, permitindo uma iteração mais rápida em alterações somente de cpp.

$ bAdaptiveUnityEnablesEditAndContinue (booleano): cria um PCH dedicado para cada arquivo de origem no conjunto de trabalho, permitindo uma iteração mais rápida em alterações somente de cpp.

$ bAdaptiveUnityCompilesHeaderFiles (booleano): cria um arquivo de origem dedicado para cada arquivo de cabeçalho no conjunto de trabalho para detectar inclusões ausentes nos cabeçalhos.

$ MinGameModuleSourceFilesForUnityBuild (Int32): o número de arquivos de origem em um módulo de jogo antes que a compilação do Unity seja ativada para esse módulo. Isso permite que módulos de jogos pequenos tenham tempos de compilação iterativos mais rápidos para arquivos únicos, às custas de tempos de recompilação completos mais lentos. Essa configuração pode ser substituída pela opção bFasterWithoutUnity em um arquivo Build.cs do módulo.

$ DefaultWarningLevel (WarningLevel): o tratamento padrão de avisos não categorizados

$ bRequireObjectPtrForAddReferencedObjects (booleano): exige TObjectPtr para APIs de FReferenceCollector. (Necessário para compatibilidade com GC incremental)

$ bValidateFormatStrings (booleano): emite erros de compilação para strings de formato UE_LOG incorretas.

$ DeprecationWarningLevel (WarningLevel): o nível para relatar avisos de depreciação como erros

$ ShadowVariableWarningLevel (WarningLevel): força que os avisos de variável sombreada sejam tratados como erros em plataformas compatíveis.

$ 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): indica qual nível de aviso/erro deve ser tratado como conversão de tipo inseguro nas plataformas com suporte (por exemplo, double->float ou int64->int32)

$ bUndefinedIdentifierErrors (booleano): força o uso de identificadores indefinidos em expressões condicionais a serem tratados como erros.

$ UndefinedIdentifierWarningLevel (WarningLevel): indica o nível de aviso/erro para tratar identificadores indefinidos em expressões condicionais.

$ PCHPerformanceIssueWarningLevel (WarningLevel): indica o nível de aviso/erro para tratar possíveis problemas de desempenho de PCH.

$ 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

$ bRetainFramePointers (booleano): força a retenção dos ponteiros de quadro, o que geralmente é necessário quando se deseja pilhas de chamadas confiáveis, por exemplo: mallocframeprofiler

$ bRetainFramePointersOverride (Nullable<Boolean>): força a retenção dos ponteiros de quadro, o que geralmente é necessário quando se deseja pilhas de chamadas confiáveis, por exemplo: mallocframeprofiler

$ bUseFastMonoCalls (booleano): os novos drivers de gráficos monolíticos têm "chamadas rápidas" opcionais que substituem várias funções D3d

$ NumIncludedBytesPerUnityCPP (Int32): um número aproximado de bytes de código C++ a ser direcionado para inclusão em um único arquivo C++ unificado.

$ bDisableModuleNumIncludedBytesPerUnityCPPOverride (booleano): desabilita as substituições definidas pelo módulo

$ bStressTestUnity (booleano): determina se a robustez da compilação do Unity em C++ deve ser testada, incluindo todos os arquivos C++ em um projeto com base em um único arquivo unificado.

$ bDetailedUnityFiles (booleano): determina se informações adicionais devem ser acrescentadas a arquivos do Unity, como "_of_X" no nome do arquivo. Não recomendado.

$ bForceDebugInfo (booleano): determina se as informações de depuração devem ser geradas forçadamente.

$ bDisableDebugInfo (booleano): se a geração de informações de depuração deve ser globalmente desabilitada; Obsoleta, use TargetRules.DebugInfoMode

$ DebugInfo (DebugInfoMode): a quantidade de informações de depuração que deve ser gerada. Consulte a enumeração DebugInfoMode para obter mais detalhes

$ DebugInfoLineTablesOnly (DebugInfoMode): verdadeiro se apenas as tabelas de números de linha de depuração devem ser emitidas em informações de depuração para compiladores com suporte para isso. Substitui TargetRules.DebugInfo Consulte https://clang.llvm.org/docs/UsersManual.html#cmdoption-gline-tables-only para obter mais informações

$ bDisableDebugInfoForGeneratedCode (booleano): determina se a geração de informações de depuração deve ser desabilitada para arquivos gerados. Isso melhora os tempos de vinculação e reduz o tamanho do pdb para módulos que têm muito código de aderência gerado.

$ bOmitPCDebugInfoInDevelopment (booleano): determina se as informações de depuração no PC/Mac devem ser desabilitadas em compilações de desenvolvimento (para uma iteração mais rápida do desenvolvedor, pois os tempos de vínculo são extremamente rápidos com as informações de depuração desabilitadas).

$ bUsePDBFiles (booleano): determina se os arquivos PDB devem ser usados para compilações do Visual C++.

$ bUsePCHFiles (booleano): determina se os arquivos PCH devem ser usados.

$ bDeterministic (booleano): define sinalizadores necessários para compilação e vinculação determinísticas. A ativação do modo determinístico para msvc desabilitada o multithreading do codegen e, portanto, a compilação será mais lenta

$ bChainPCHs (booleano): determina se os PCHs devem ser encadeados ao compilar com o Clang.

$ bForceIncludePCHHeadersForGenCppFilesWhenPCHIsDisabled (booleano): determina se os cabeçalhos do PCH devem ser incluídos forçadamente nos arquivos gen.cpp quando o PCH estiver desabilitado.

$ bPreprocessOnly (booleano): determina se os arquivos de origem devem ser pré-processados e se a compilação deve ser ignorada

$ bPreprocessDepends (booleano): gera arquivos de dependências por meio de pré-processamento. Somente recomendado ao distribuir compilações, pois adiciona mais sobrecarga.

$ bWithAssembly (booleano): determina se os dados de montagem devem ser gerados durante a compilação deste destino. Por enquanto, funciona exclusivamente no MSVC.

$ bAllowUbaCompression (booleano): experimental: armazena o objeto (.obj) compactado no disco. Exige UBA para vincular, no momento apenas MSVC. A ativação desse sinalizador invalidará as ações do MSVC. Atenção: esta opção não é compatível com PGO ou o vinculador cl-clang, pois eles não foram desviados e a vinculação falhará.

$ StaticAnalyzer (StaticAnalyzer): determina se a análise de código estático deve ser habilitada.

$ StaticAnalyzerOutputType (StaticAnalyzerOutputType): o tipo de saída a ser usado para o analisador estático. Isso apenas é compatível com o Clang.

$ StaticAnalyzerMode (StaticAnalyzerMode): o modo a ser usado para o analisador estático. Isso apenas é compatível com o Clang. O modo raso é concluído mais rapidamente, mas geralmente não é recomendado.

$ StaticAnalyzerPVSPrintLevel (Int32): o nível de avisos a serem impressos ao analisar usando o PVS-Studio

$ bStaticAnalyzerProjectOnly (booleano): executa a análise estática somente em relação aos módulos do projeto, ignorando os módulos da engine

$ bStaticAnalyzerIncludeGenerated (booleano): quando habilitada, os arquivos de origem gerados serão analisados

$ MinFilesUsingPrecompiledHeader (Int32): o número mínimo de arquivos que devem usar um cabeçalho pré-compilado antes que ele seja criado e usado.

$ bForcePrecompiledHeaderForGameModules (booleano): quando habilitada, um cabeçalho pré-compilado é sempre gerado para módulos de jogos, mesmo que haja apenas alguns arquivos de origem no módulo. Isso melhora muito os tempos de compilação para alterações iterativas em alguns arquivos do projeto, às custas de tempos mais lentos de reconstrução completa para projetos de jogos pequenos. Isso pode ser substituído com a configuração de MinFilesUsingPrecompiledHeaderOverride no arquivo Build.cs de um módulo.

$ bUseIncrementalLinking (booleano): determina se a vinculação incremental deve ou não ser usada. A vinculação incremental pode gerar tempos de iteração mais rápidos ao fazer pequenas alterações. Atualmente, está desabilitado por padrão, pois tende a apresentar alguns bugs em alguns computadores (erros de compilação relacionados a PDB).

$ bAllowLTCG (booleano): determina se o uso da geração de código de tempo de link (LTCG) deve ser permitido.

$ bPreferThinLTO (booleano): quando a Geração de Código de Tempo de Link (LTCG) está habilitada, determina se é preferível usar a versão mais leve nas plataformas compatíveis.

$ ThinLTOCacheDirectory (String): o diretório onde colocar o cache ThinLTO nas plataformas compatíveis.

$ ThinLTOCachePruningArguments (String): argumentos que serão aplicados para aparar o cache ThinLTO em plataformas compatíveis. Os argumentos somente serão aplicados se ThinLTOCacheDirectory estiver definido.

$ bPGOProfile (booleano): determina se a instrumentação de Otimização Guiada por Perfil (PGO) deve ser habilitada nessa compilação.

$ bPGOOptimize (booleano): determina se essa compilação deve ser otimizada com a Otimização Guiada por Perfil (PGO).

$ bCodeCoverage (booleano): determina se o destino exige compilação e vinculação de cobertura de código.

$ bSupportEditAndContinue (booleano): determina se deve haver suporte para editar e continuar.

$ bOmitFramePointers (booleano): determina se ponteiros de quadro devem ou não ser omitidos. A desativação é útil, por exemplo, para criação de perfil de memória no PC.

$ bCompressDebugFile (booleano): se quisermos compactar os arquivos de depuração

$ bEnableCppModules (booleano): determina se o suporte para módulos C++20

$ bEnableCppCoroutinesForEvaluation (booleano): determina se o suporte para corrotinas C++20 deve ser habilitado. Essa opção é fornecida para facilitar a avaliação da funcionalidade. Espere o nome da opção mudar. O uso de corrotinas na UE não foi testado nem é compatível.

$ bEnableProcessPriorityControl (booleano): determina se a capacidade da engine de definir a prioridade do processo em tempo de execução deve ser habilitada. Essa opção requer uma configuração do ambiente no Linux, por isso está desabilitado por padrão. O projeto precisa ativar essa funcionalidade, pois precisa garantir uma configuração correta.

$ bUseMallocProfiler (booleano): se for verdadeira, habilita a análise de memória na compilação (define USE_MALLOC_PROFILER=1 e força bOmitFramePointers=false).

$ bShaderCompilerWorkerTrace (booleano): se verdadeiro, habilite a criação de perfil do Unreal Insights (utrace) na compilação para o Trabalhador do Compilador do Sombreador (define USE_SHADER_COMPILER_WORKER_TRACE=1).

$ bUseSharedPCHs (booleano): habilita "PCHs Compartilhados", um recurso que acelera significativamente os tempos de compilação ao tentar compartilhar determinados arquivos PCH entre módulos que a UBT detecta que estão incluindo os arquivos de cabeçalho desses PCHs.

$ bUseShippingPhysXLibraries (booleano): verdadeiro se as compilações de desenvolvimento e versão devem usar a configuração de versão de PhysX/APEX.

$ bUseCheckedPhysXLibraries (booleano): verdadeiro se as compilações de desenvolvimento e versão devem usar a configuração verificada de PhysX/APEX. se bUseShippingPhysXLibraries for verdadeiro, isso será ignorado.

$ bCheckLicenseViolations (booleano): diz à UBT que verifique se o módulo que está sendo construído no momento está violando o EULA.

$ bBreakBuildOnLicenseViolation (booleano): informa à UBT que interrompa a compilação se o módulo que estiver sendo compilado no momento estiver violando o EULA.

$ bUseFastPDBLinking (Nullable<Boolean>): se a opção :FASTLINK deve ser usada ao compilar com /DEBUG para criar PDBs locais no Windows. Rápida, mas atualmente parece ter problemas para localizar símbolos no depurador.

$ bCreateMapFile (booleano): gera um arquivo de mapa como parte da compilação.

$ bAllowRuntimeSymbolFiles (booleano): verdadeiro se arquivos de símbolos de tempo de execução devem ser gerados como uma etapa pós-compilação para algumas plataformas. Esses arquivos são usados pela engine para resolver nomes de símbolos de rastreamentos de pilha de chamadas nos logs.

$ PackagePath (string): caminho completo do pacote (diretório + nome do arquivo) no qual armazenar os arquivos de entrada usados no momento da vinculação Normalmente usado para depurar uma falha do vinculador em plataformas com suporte

$ CrashDiagnosticDirectory (string): o diretório no qual colocar os arquivos de relatório de falhas para as plataformas com suporte

BundleVersion (string): a versão do pacote para aplicativos do Mac.

$ bDeployAfterCompile (booleano): define se o executável após a compilação será implementado em plataformas que exigem implementação.

$ bAllowRemotelyCompiledPCHs (booleano): quando habilitada, permite que o XGE compile arquivos de cabeçalho pré-compilados em máquinas remotas. Caso contrário, os PCHs são sempre gerados localmente.

$ bUseHeaderUnitsForPch (booleano): substituirá pch por ifc e usará unidades de cabeçalho. Este é um recurso experimental e exclusivo do MSVC

$ bCheckSystemHeadersForModification (booleano): se os cabeçalhos nos caminhos do sistema devem ser verificados quanto a modificações ao determinar ações desatualizadas.

$ bDisableLinking (booleano): determina se a vinculação deve ser desabilitada para este destino.

$ bIgnoreBuildOutputs (booleano): determina se o rastreamento de saídas de compilação deve ser ignorado para este destino.

$ bDisableEngineDeprecations (booleano): determina se os avisos de descontinuação da UE_DEPRECATED_FORENGINE devem ser desabilitados em módulos que não são da engine. Isso só deve ser usado em curto prazo, pois as versões descontinuadas serão removidas.

$ bFormalBuild (booleano): indica que é uma compilação formal destinada à distribuição. Esse sinalizador é definido automaticamente como verdadeiro quando Build.version tem uma lista de alterações definida e é uma compilação promovida. No momento, o único comportamento vinculado a esse sinalizador é compilar o arquivo de recurso padrão separadamente para cada binário, de modo que o campo OriginalFilename esteja definido corretamente. Por padrão, o recurso é compilado uma vez para reduzir o tempo de compilação.

$ bFlushBuildDirOnRemoteMac (booleano): determina se o diretório Builds deve ser limpo em um Mac remoto antes da compilação.

$ bPrintToolChainTimingInfo (booleano): determina se as informações detalhadas de tempo do compilador e do vinculador devem ser gravadas.

$ bParseTimingInfoForTracing (booleano): determina se os dados de tempo devem ser analisados em um arquivo de rastreamento compatível com chrome://tracing.

$ bPublicSymbolsByDefault (booleano): determina se todos os símbolos devem ser expostos como públicos por padrão em plataformas POSIX

$ bDisableInliningGenCpps (booleano): desabilita suportes para inclusão de gen.cpps em linha

$ ToolChainName (String): permite a sobreposição da cadeia de ferramentas a ser criada para esse destino. Deve corresponder ao nome de uma classe declarada no conjunto UnrealBuildTool.

$ MSVCCompileActionWeight (único): o peso (utilização de cpu/memória) de uma ação de compilação do MSVC

$ ClangCompileActionWeight (único): o peso (utilização de cpu/memória) de uma ação de compilação do Clang

$ bDisableUnverifiedCertificates (booleano): determina se a configuração da engine tem permissão para definir se é possível carregar certificados não verificados.

$ bAllowGeneratedIniWhenCooked (booleano): determina se os arquivos .ini gerados devem ser carregados na versão preparada (GameUserSettings.ini é carregado de qualquer maneira)

$ bAllowNonUFSIniWhenCooked (booleano): determina se os arquivos .ini gerados que não são do UFS devem ser carregados na versão preparada (GameUserSettings.ini é carregado de qualquer maneira)

$ bLegacyPublicIncludePaths (booleano): adiciona todas as pastas públicas como caminhos de inclusão para o ambiente da compilação.

$ bLegacyParentIncludePaths (booleano): adiciona todas as pastas-pai como caminhos de inclusão para o ambiente de compilação.

$ CppStandardEngine (CppStandardVersion): o padrão C++ a ser usado para compilar esse destino (para módulos da engine)

$ CppStandard (CppStandardVersion): o padrão C++ a ser usado para compilar esse destino (para módulos que não são da engine)

$ CStandard (CStandardVersion): qual padrão C deve ser usado para compilar esse destino

$ MinCpuArchX64 (MinimumCpuArchitectureX64): direciona o compilador para gerar instruções AVX sempre que forem usados intrínsecos SSE ou AVX em plataformas x64 com suporte. Ignorada para arm64. Observe que, ao habilitar essa opção, você está alterando o minspec para a plataforma de destino, e o executável resultante falhará em máquinas sem suporte para AVX.

$ BuildVersion (String): a string da versão de compilação.

$ LinkType (TargetLinkType): especifica como vincular módulos neste destino (monolítico ou modular). Atualmente, isso está protegido para fins de compatibilidade com versões anteriores. Faça a chamada do acessador GetLinkType() até que a compatibilidade com a substituição descontinuada ShouldCompileMonolithic() seja removida.

$ bStripExports (booleano): experimental: remove exportações não utilizadas das bibliotecas. Aplica-se apenas quando LinkType é modular

$ bMergeModules (booleano): experimental: mescla módulos modulares em bibliotecas combinadas. Define LinkType como modular e habilita bStripExports

$ LaunchModuleName (string): especifica o nome do módulo de inicialização. Para compilações modulares, esse é o módulo compilado no executável de destino.

$ ExportPublicHeader (String): especifica o caminho para escrever um cabeçalho com definições públicas para este destino. Útil na criação de uma DLL para ser consumida por processos de compilação externos.

$ BuildEnvironment (TargetBuildEnvironment): especifica o ambiente de compilação para este destino. Confira TargetBuildEnvironment para obter mais informações sobre as opções disponíveis.

$ bAllowSDKOverrideModulesWithSharedEnvironment (booleano): Se verdadeiro, um destino de ambiente de compilação compartilhado permitirá que quaisquer módulos sensíveis à versão do SDK tenham um módulo no projeto quando um SDK for substituído. Por exemplo, se IOSTargetPlatform, que está marcado como relevante para a versão do IOS SDK, for compilado para um destino com esta opção definida como verdadeiro e esse destino substituir o IOS SDK, a compilação iria para, por exemplo, MyProject/Binaries/Win64/IOS/MyProject-IOSTargetPlatform.dll

$ bOverrideBuildEnvironment (booleano): determina se devem ser ignoradas as infrações ao ambiente de compilação compartilhado (por exemplo, definições de modificação de destinos do editor)

$ AdditionalCompilerArguments (string): argumentos adicionais a serem passados ao compilador

$ AdditionalLinkerArguments (string): argumentos adicionais a serem passados ao vinculador

$ MemoryPerActionGB (double): quantidade máxima de memória que cada ação de compilação pode exigir. Usado pelo ParallelExecutor para decidir o número máximo de ações paralelas a serem iniciadas por vez.

$ GeneratedProjectName (string): ao gerar arquivos de projeto, especifica o nome do arquivo de projeto a ser usado quando houver vários destinos do mesmo tipo.