UnrealBuildTool

Helper class for directory mapping

Creating cache

Root of the project

Given a file, return the artifact structure for it. This routine tests to see if the file is under any of the well known directories.

Action requesting the artifact File in question Hash value used to populate artifact Created artifact

Create an artifact with the given settings

Directory tree Path to artifact Hash of the artifact The artifact

Generic handler for artifacts

Logging device

Cache of dependency files.

Cache for file hashes

Directory mapper to be used for targets without projects

Artifact mappers for all targets

Construct a new artifact handler object

Artifact cache instance Previously created dependency cache Logging device

Create a new action artifact cache using horde file based storage

Directory for the cache Previously created dependency cache Cache for memory mapped files Logging device Action artifact cache object

Create a new action artifact cache using horde memory based storage

Previously created dependency cache Logging device Action artifact cache object

Create a new artifact action that represents the input and output of the action

Source action Cancellation token Artifact action

Get the key has for the action

Directory mapping object Source action Inputs used to construct the key Task returning the key

Generate the key and action key hashes for the action

Directory mapping object Source action Inputs used to construct the key Dependencies used to construct the key Task object with the key and action key

Generate the lookup key. This key is generated from the action's inputs.

Destination builder Directory mapping object Source action Inputs used to construct the key Task object

Generate the full action key. This contains the hashes for the action's inputs and the dependent files.

Destination builder Directory mapping object Source action Dependencies used to construct the key Task object

Append the file information for a given list of files

Destination builder Directory mapping object Source action Collection of files Task object

Given an action, collect the list of inputs and dependencies. This includes any processing required for disabled actions that propagate their inputs to dependent actions.

Action in question If true, collect the dependencies too Collection of inputs and dependencies

Add a list of file items to the collection

Hash set used to detect already included file items Substitutions when a given input is found Destination list Source inputs

Return the tree name of the artifact

Artifact in question Tree name

Return an artifact mapper for the given action

Action in question Artifact mapper specific to the target's project directory

Artifacts can exist in different directory roots.

Absolute path

Input/Output exists in the engine directory tree

Input/Outputs exists in the project directory tree

Represents a single artifact file

Directory tree containing the artifact Name of the artifact Hash of the artifact contents

Represents a single artifact file

Directory tree containing the artifact Name of the artifact Hash of the artifact contents

Directory tree containing the artifact

Name of the artifact

Hash of the artifact contents

The full path of the artifact

Mapping object to use instead of embedded object Full path of the artifact

Collection of inputs and outputs for an action

The hash of the primary input and the environment The unique hash for all inputs and the environment Information about all inputs Information about all outputs

Collection of inputs and outputs for an action

The hash of the primary input and the environment The unique hash for all inputs and the environment Information about all inputs Information about all outputs

The hash of the primary input and the environment

The unique hash for all inputs and the environment

Information about all inputs

Information about all outputs

Directory mapping object

Collection of helper extension methods for working with IMemoryReader/Writer

Read an artifact structure

Source reader Read artifact structure

Write an artifact structure

Destination writer Artifact to be written

Read an artifact action structure

Source reader Read artifact action structure

Write an artifact action structure

Destination writer Artifact action to be written

Represents the state of the cache. It is expect that after construction, the cache can be in pending state, but this is optional. From the pending state, the cache becomes available or unavailable.

The cache is still initializing

There has been some form of cache failure and it is unavailable

The cache is functional and ready to process requests

Interface used to map a directory tree to an actual directory

Return the directory root for the given tree

Tree in question Directory root

Interface for querying and adding artifacts

Return true if the cache is ready to process requests

Return task that waits for the cache to be ready

State of the artifact cache

Given a collection of partial keys return all matching artifacts

Source file key Token to be used to cancel operations Collection of all known artifacts

Query the actual contents of a group of artifacts

Actions to be read Token to be used to cancel operations Dictionary of the artifacts

Save new artifact to the cache

Collection of artifacts to be saved Token to be used to cancel operations Asynchronous task objects

Flush all updates in the cache asynchronously.

Token to be used to cancel operations Asynchronous task objects

Struct containing results from artifact fetch

Is set to true if succeeded in fetching artifacts Contains log lines if any

Struct containing results from artifact fetch

Is set to true if succeeded in fetching artifacts Contains log lines if any

Is set to true if succeeded in fetching artifacts

Contains log lines if any

Interface for action specific support of artifacts.

Underlying artifact cache

If true, reads will be serviced

If true, writes will be propagated to storage

If true, log all cache misses. Defaults to false.

Root location of the engine

Array of extra directory roots when handling relative directories. The array MUST be consistent between runs since only the index is saved.

Complete an action from existing cached data

Action to be completed Token to be used to cancel operations True if it has been completed, false if not

Save the output for a completed action

Completed action Token to be used to cancel operations Asynchronous task object

Flush all updates in the cache asynchronously.

Token to be used to cancel operations Asynchronous task object

Horde specific artifact action structure that also contains the file nodes for the outputs

Artifact action

Collection of output file references. There should be exactly the same number of file references as outputs in the action

Construct a new horde artifact number

Artifact action

Construct a new artifact action from the reader

Source reader

Serialize the artifact action

Destination writer

Write all the files to disk

Destination writer Cancellation token Task

Series of helper methods for serialization

Read a horde artifact action

Source reader Created artifact action

Write a horde artifact action

Destination writer Artifact action to write

Horde node that represents a collection of action nodes

Collection of actions

Construct a new collection

Class for managing artifacts using horde storage

Defines the theoretical max number of pending actions to write

Underlying storage object

Task used to wait on ready state

Ready state

Collection of actions waiting to be written

Task for any pending flush

Controls access to shared data structures

Test to see if the cache is ready

Create a memory only cache

Create a file based cache

Destination directory Cache for memory mapped files Logging object If true, clean the directory

Constructor

Storage object to use

Optionally flush all pending writes

If true, force a flush Cancellation token

Add a group of artifact actions to a new or existing source

New artifact actions to add Token to be used to cancel operations List of tasks

Initialize a file based cache

Destination directory Cache for memory mapped files Logger If true, clean the directory Cache state

Return the ref name for horde storage given a artitfact action collection key

Artifact action collection key The reference name

Global settings for building. Should not contain any target-specific settings.

Whether to ignore import library files that are out of date when building targets. Set this to true to improve iteration time. By default, we do not bother re-linking targets if only a dependent .lib has changed, as chances are that the import library was not actually different unless a dependent header file of this target was also changed, in which case the target would automatically be rebuilt.

Use existing static libraries for all engine modules in this target.

Whether debug info should be written to the console.

Whether the hybrid executor will be used (a remote executor and local executor). No longer supported.

Priority order for remote executors (XGE, SNDBS, FASTBuild, UBA)

Whether the UnrealBuildAccelerator executor will be used.

Whether the UnrealBuildAccelerator (local only) executor will be used.

Whether XGE may be used if available, default is true.

Whether FASTBuild may be used if available, default is true.

Whether SN-DBS may be used if available, default is true.

Enables support for very fast iterative builds by caching target data. Turning this on causes Unreal Build Tool to emit 'UBT Makefiles' for targets when they are built the first time. Subsequent builds will load these Makefiles and begin outdatedness checking and build invocation very quickly. The caveat is that if source files are added or removed to the project, UBT will need to gather information about those in order for your build to complete successfully. Currently, you must run the project file generator after adding/removing source files to tell UBT to re-gather this information. Events that can invalidate the 'UBT Makefile': - Adding/removing .cpp files - Adding/removing .h files with UObjects - Adding new UObject types to a file that did not previously have any - Changing global build settings (most settings in this file qualify) - Changed code that affects how Unreal Header Tool works You can force regeneration of the 'UBT Makefile' by passing the '-gather' argument, or simply regenerating project files. This also enables the fast include file dependency scanning and caching system that allows Unreal Build Tool to detect out of date dependencies very quickly. When enabled, a deep C++ include graph does not have to be generated, and instead, we only scan and cache indirect includes for after a dependent build product was already found to be out of date. During the next build, we will load those cached indirect includes and check for outdatedness.

Number of actions that can be executed in parallel. If 0 then code will pick a default based on the number of cores and memory available. Applies to the ParallelExecutor, HybridExecutor, and LocalExecutor

Consider logical cores when determining how many total cpu cores are available.

If true, force header regeneration. Intended for the build machine.

If true, do not build UHT, assume it is already built.

If true, fail if any of the generated header files is out of date.

True if hot-reload from IDE is allowed.

If true, the Debug version of UnrealHeaderTool will be built and run instead of the Development version.

If true, use C# UHT internal to UBT

If true, generate warnings when C++ UHT is used

Whether to skip compiling rules assemblies and just assume they are valid

Whether to force compiling rules assemblies, regardless of whether they are valid

Maximum recommended root path length.

Maximum length of a path relative to the root directory. Used on Windows to ensure paths are portable between machines.

When single file targets are specified, via -File=, -SingleFile=, or -FileList= If this option is set, no error will be produced if the source file is not included in the target. Additionally, if any file or file list is specified, the target will not be built if none of the specified files are part of that target, including the case where a file specified via -FileList= is empty.

Instruct the executor to write compact output e.g. only errors, if supported by the executor. This field is used to hold the value when specified from the command line or XML

If set, artifacts will be read

If set, artifacts will be written

If true, log all artifact cache misses as informational messages

Location to store the artifacts.

Instruct the executor to write compact output e.g. only errors, if supported by the executor, and only if output is not being redirected e.g. during a build from within Visual Studio

Whether to unify C++ code into larger files for faster compilation.

Whether to force C++ source files to be combined into larger files for faster compilation.

Intermediate environment. Determines if the intermediates end up in a different folder than normal.

Controls how a particular warning is treated

Use the default behavior

Do not display diagnostics

Output warnings normally

Output warnings as errors

Describes the origin and visibility of Verse code

Created by Epic and only public definitions will be visible to public users

Created by Epic and is entirely hidden from public users

Created by a public user

Created by an Epic internal user

To what extent a module supports include-what-you-use

None means code does not even compile. IWYU needs to skip this module entirely

Module could be modified with iwyu but we want it to stay the way it is and handle changes manually

Module is parsed and processed. This means that from the outside it is stripped for includes even though the files are not modified. This can be used to defer iwyu work on a module. When it comes to transitive includes this module is seen as modified from the outside.

Same as KeepAsIsForNow but will allow iwyu to update private headers and cpp files.

Full iwyu support. When running with -Mode=IWYU this module will be modified if needed

ModuleRules is a data structure that contains the rules for defining a module

Type of module

C++

External (third-party)

Override the settings of the UHTModuleType to have a different set of PKG_ flags. Cannot set on a plugin because that value already set in the '.uplugin' file

Do not override the package type on this module

Set the PKG_EditorOnly flag on this module

Set the PKG_Developer on this module

Set the PKG_Developer on this module

Set the PKG_UncookedOnly flag on this module

Set the PKG_UncookedOnly flag on this module as a game

Code optimization settings

Code should never be optimized if possible.

Code should only be optimized in non-debug builds (not in Debug).

Code should only be optimized in shipping builds (not in Debug, DebugGame, Development)

Code should always be optimized if possible.

Default: 'InNonDebugBuilds' for game modules, 'Always' otherwise.

What type of PCH to use for this module.

Default: Engine modules use shared PCHs, game modules do not

Never use any PCHs.

Never use shared PCHs. Always generate a unique PCH for this module if appropriate

Shared PCHs are OK!

Shared PCHs may be used if an explicit private PCH is not set through PrivatePCHHeaderFile. In either case, none of the source files manually include a module PCH, and should include a matching header instead.

Which type of targets this module should be precompiled for

Never precompile this module.

Inferred from the module's directory. Engine modules under Engine/Source/Runtime will be compiled for games, those under Engine/Source/Editor will be compiled for the editor, etc...

Any game targets.

Any editor targets.

Any targets.

Control visibility of symbols in this module for special cases

Standard visibility rules

Make sure symbols in this module are visible in Dll builds

Information about a file which is required by the target at runtime, and must be moved around with it.

The file that should be staged. Should use $(EngineDir) and $(ProjectDir) variables as a root, so that the target can be relocated to different machines.

The initial location for this file. It will be copied to Path at build time, ready for staging.

How to stage this file.

Constructor

Path to the runtime dependency How to stage the given path

Constructor

Path to the runtime dependency Source path for the file in the working tree How to stage the given path

List of runtime dependencies, with convenience methods for adding new items

Inner list of runtime dependencies

Readonly access of inner list of runtime dependencies

Default constructor

Add a runtime dependency to the list

Path to the runtime dependency. May include wildcards.

Add a runtime dependency to the list

Path to the runtime dependency. May include wildcards. How to stage this file

Add a runtime dependency to the list

Path to the runtime dependency. May include wildcards. Source path for the file to be added as a dependency. May include wildcards. How to stage this file

List of runtime dependencies, with convenience methods for adding new items

Inner list of runtime dependencies

Readonly access of inner list of runtime dependencies

Default constructor

Add a receipt property to the list

Name of the property Value for the property

Remove recepit properties from the list

the maatcher predicate the number of items removed

Stores information about a framework on IOS or MacOS

Name of the framework

Specifies the path to a zip file that contains it or where the framework is located on disk

How to handle linking and copying the framework

Pass this framework to the linker

Copy this framework into the final .app

Both link into executable and copy into .app

How to treat the framework during linking and creating the .app

Constructor

Name of the framework Path to a zip file containing the framework or a framework on disk Copy the framework to the target's Framework directory

Constructor

Name of the framework Path to a zip file containing the framework or a framework on disk How to treat the framework during linking and creating the .app

Specifies if the file is a zip file

Constructor

Information about a Windows type library (TLB/OLB file) which requires a generated header.

Name of the type library

Additional attributes for the #import directive

Name of the output header

Name of the output include

Constructor

Name of the type library. Follows the same conventions as the filename parameter in the MSVC #import directive. Additional attributes for the import directive Name of the output header Name of the output include

Name of this module

File containing this module

Directory containing this module

The Directory that contains either the Build.cs file, or the platform extension's SubClass directory

Returns true if the rules are a platform extension subclass

Additional directories that contribute to this module (likely in UnrealBuildTool.EnginePlatformExtensionsDirectory). The dictionary tracks module subclasses

Additional directories that contribute to this module but are not based on a subclass (NotForLicensees, etc)

The rules assembly to use when searching for modules

Plugin containing this module

True if a Plugin contains this module

The rules context for this instance

Rules for the target that this module belongs to

Type of module

Accessor for the target logger

Overridden type of module that will set different package flags. Cannot be used for modules that are a part of a plugin because that is set in the `.uplugin` file already.

Returns true if there has been an override type specified on this module

Subfolder of Binaries/PLATFORM folder to put this module in when building DLLs. This should only be used by modules that are found via searching like the TargetPlatform or ShaderFormat modules. If FindModules is not used to track them down, the modules will not be found.

When this module's code should be optimized.

Allows fine tuning optimization level for speed and\or code size. This requires a private PCH (or NoPCHs, which is not recommended)

Allows overriding the FP semantics for this module. This requires a private PCH (or NoPCHs, which is not recommended)

Header files that should be force included for every source file in this module.

Explicit private PCH for this module. Implies that this module will not use a shared PCH.

Header file name for a shared PCH provided by this module. Must be a valid relative path to a public C++ header file. This should only be set for header files that are included by a significant number of other C++ modules.

Specifies an alternate name for intermediate directories and files for intermediates of this module. Useful when hitting path length limitations.

Precompiled header usage for this module

Whether this module should be treated as an engine module (eg. using engine definitions, PCHs, compiled with optimizations enabled in DebugGame configurations, etc...). Initialized to a default based on the rules assembly it was created from.

If this contains a platform and the project has had it's SDK version overriden from default, this module will be compiled as a project module, instead of shared engine module

Emits compilation errors for incorrect UE_LOG format strings.

Emits deprecated warnings\errors for internal API usage for non-engine modules

Which engine version's build settings to use by default.

What version of include order to use when compiling this module. Can be overridden via -ForceIncludeOrder on the command line or in a module's rules.

Use run time type information

Whether to direct MSVC to remove unreferenced COMDAT functions and data.

zc-inline-remove-unreferenced-comdat

Enable code coverage compilation/linking support.

Obsolete: Direct the compiler to generate AVX instructions wherever SSE or AVX intrinsics are used, on the platforms that support it. Note that by enabling this you are changing the minspec for the PC platform, and the resultant executable will crash on machines without AVX support.

Direct the compiler to generate AVX instructions wherever SSE or AVX intrinsics are used, on the x64 platforms that support it. Note that by enabling this you are changing the minspec for the PC platform, and the resultant executable will crash on machines without AVX support.

Enable buffer security checks. This should usually be enabled as it prevents severe security risks.

Enable exception handling

Enable objective C exception handling

Enable objective C automatic reference counting (ARC) If you set this to true you should not use shared PCHs for this module. The engine won't be extensively using ARC in the short term Not doing this will result in a compile errors because shared PCHs were compiled with different flags than consumer

How to treat deterministic warnings (experimental).

How to treat shadow variable warnings

Whether to enable all warnings as errors. UE enables most warnings as errors already, but disables a few (such as deprecation warnings).

`

How to treat unsafe implicit type cast warnings (e.g., double->float or int64->int32)

Indicates what warning/error level to treat undefined identifiers in conditional expressions.

Enable warnings for using undefined identifiers in #if expressions

How to treat general module include path validation messages

How to treat private module include path validation messages, where a module is adding an include path that exposes private headers

How to treat unnecessary module sub-directory include path validation messages

Disable all static analysis - clang, msvc, pvs-studio.

Enable additional analyzer extension warnings using the EspXEngine plugin. This is only supported for MSVC. See https://learn.microsoft.com/en-us/cpp/code-quality/using-the-cpp-core-guidelines-checkers This will add a large number of warnings by default. It's recommended to use StaticAnalyzerRulesets if this is enabled.

The static analyzer rulesets that should be used to filter warnings. This is only supported for MSVC. See https://learn.microsoft.com/en-us/cpp/code-quality/using-rule-sets-to-specify-the-cpp-rules-to-run

The static analyzer checkers that should be enabled rather than the defaults. This is only supported for Clang. See https://clang.llvm.org/docs/analyzer/checkers.html for a full list. Or run: 'clang -Xclang -analyzer-checker-help' or: 'clang -Xclang -analyzer-checker-help-alpha' for the list of experimental checkers.

The static analyzer default checkers that should be disabled. Unused if StaticAnalyzerCheckers is populated. This is only supported for Clang. See https://clang.llvm.org/docs/analyzer/checkers.html for a full list. Or run: 'clang -Xclang -analyzer-checker-help' or: 'clang -Xclang -analyzer-checker-help-alpha' for the list of experimental checkers.

The static analyzer non-default checkers that should be enabled. Unused if StaticAnalyzerCheckers is populated. This is only supported for Clang. See https://clang.llvm.org/docs/analyzer/checkers.html for a full list. Or run: 'clang -Xclang -analyzer-checker-help' or: 'clang -Xclang -analyzer-checker-help-alpha' for the list of experimental checkers.

The PVS Studio analysis errors that should be disabled.

If unity builds are enabled this can be used to override if this specific module will build using Unity. This is set using the per module configurations in BuildConfiguration.

Whether to merge module and generated unity files for faster compilation.

The number of source files in this module before unity build will be activated for that module. If set to anything besides -1, will override the default setting which is controlled by MinGameModuleSourceFilesForUnityBuild

Overrides BuildConfiguration.MinFilesUsingPrecompiledHeader if non-zero.

Overrides Target.NumIncludedBytesPerUnityCPP if non-zero.

Helper function to get the number of byes per unity cpp file

Module uses a #import so must be built locally when compiling with SN-DBS

Enable warnings for when there are .gen.cpp files that could be inlined in a matching handwritten cpp file

Redistribution override flag for this module.

Whether the output from this module can be publicly distributed, even if it has code/ dependencies on modules that are not (i.e. CarefullyRedist, NotForLicensees, NoRedist). This should be used when you plan to release binaries but not source.

List of folders which are allowed to be referenced when compiling this binary, without propagating restricted folder names

Set of aliased restricted folder references

Enforce "include what you use" rules when PCHUsage is set to ExplicitOrSharedPCH; warns when monolithic headers (Engine.h, UnrealEd.h, etc...) are used, and checks that source files include their matching header first.

Allows "include what you use" to modify the source code when run. bEnforceIWYU must be true for this variable to matter.

Whether to add all the default include paths to the module (eg. the Source/Classes folder, subfolders under Source/Public).

Whether to ignore dangling (i.e. unresolved external) symbols in modules

Whether this module should be precompiled. Defaults to the bPrecompile flag from the target. Clear this flag to prevent a module being precompiled.

Whether this module should use precompiled data. Always true for modules created from installed assemblies.

Whether this module can use PLATFORM_XXXX style defines, where XXXX is a confidential platform name. This is used to ensure engine or other shared code does not reveal confidential information inside an #if PLATFORM_XXXX block. Licensee game code may want to allow for them, however.

Disables AutoRTFM instrumentation to this module only when AutoRTFMCompiler is enabled

List of modules names (no path needed) with header files that our module's public headers needs access to, but we don't need to "import" or link against.

List of public dependency module names (no path needed) (automatically does the private/public include). These are modules that are required by our public source files.

List of modules name (no path needed) with header files that our module's private code files needs access to, but we don't need to "import" or link against.

List of private dependency module names. These are modules that our private code depends on but nothing in our public include files depend on.

Only for legacy reason, should not be used in new code. List of module dependencies that should be treated as circular references. This modules must have already been added to either the public or private dependent module list.

List of system/library include paths - typically used for External (third party) modules. These are public stable header file directories that are not checked when resolving header dependencies.

(This setting is currently not need as we discover all files from the 'Public' folder) List of all paths to include files that are exposed to other modules

(This setting is currently not need as we discover all files from the 'Internal' folder) List of all paths to include files that are exposed to other internal modules

List of all paths to this module's internal include files, not exposed to other modules (at least one include to the 'Private' path, more if we want to avoid relative paths)

List of system library paths (directory of .lib files) - for External (third party) modules please use the PublicAdditionalLibaries instead

List of search paths for libraries at runtime (eg. .so files)

List of search paths for libraries at runtime (eg. .so files)

List of additional libraries (names of the .lib files including extension) - typically used for External (third party) modules

List of additional debug visualizers (.natvis and .natstepfilter) exposed to other modules - typically used for External (third party) modules

Per-architecture lists of dependencies for linking to ignore (useful when building for multiple architectures, and a lib only is needed for one architecture), it's up to the Toolchain to use this

Returns the directory of where the passed in module name lives.

Name of the module Directory where the module lives

List of additional pre-build libraries (names of the .lib files including extension) - typically used for additional targets which are still built, but using either TargetRules.PreBuildSteps or TargetRules.PreBuildTargets.

List of system libraries to use - these are typically referenced via name and then found via the system paths. If you need to reference a .lib file use the PublicAdditionalLibraries instead

List of XCode frameworks (iOS and MacOS)

List of weak frameworks (for OS version transitions)

List of addition frameworks - typically used for External (third party) modules on Mac and iOS

List of addition resources that should be copied to the app bundle for Mac or iOS

List of type libraries that we need to generate headers for (Windows only)

List of delay load DLLs - typically used for External (third party) modules

Private compiler definitions for this module

Public compiler definitions for this module

Append (or create)

Addition modules this module may require at run-time

List of files which this module depends on at runtime. These files will be staged along with the target.

List of additional properties to be added to the build receipt

Which targets this module should be precompiled for

External files which invalidate the makefile if modified. Relative paths are resolved relative to the .build.cs file.

Subclass rules files which invalidate the makefile if modified.

Whether this module requires the IMPLEMENT_MODULE macro to be implemented. Most UE modules require this, since we use the IMPLEMENT_MODULE macro to do other global overloads (eg. operator new/delete forwarding to GMalloc).

If this module has associated Verse code, this is the Verse root path of it

Visibility of Verse code in this module's Source/Verse folder

Whether this module qualifies included headers from other modules relative to the root of their 'Public' folder. This reduces the number of search paths that have to be passed to the compiler, improving performance and reducing the length of the compiler command line.

Whether this module qualifies included headers from other modules relative to the parent directory. This reduces the number of search paths that have to be passed to the compiler, improving performance and reducing the length of the compiler command line.

Whether circular dependencies will be validated against the allow list Circular module dependencies result in slower builds. Disabling this option is strongly discouraged. This option is ignored for Engine modules which will always be validated against the allow list.

Which stanard to use for compiling this module

Which standard to use for compiling this module

A list of subdirectory names and functions that are invoked to generate header files. The subdirectory name is appended to the generated code directory to form a new directory that headers are generated inside.

Control visibility of symbols

The AutoSDK directory for the active host platform

The current engine directory

Property for the directory containing this plugin. Useful for adding paths to third party dependencies.

Property for the directory containing this module. Useful for adding paths to third party dependencies.

Property for the directory containing this module or the platform extension's subclass. Useful for adding paths to third party dependencies.

Name of a platform under the PlatformModuleDirectory - for a PlatfomrExtension, we don't use platform subdirectories since it's already in a platform dir, so this returns '.'

Returns module's low level tests directory "Tests".

Constructor. For backwards compatibility while the parameterless constructor is being phased out, initialization which would happen here is done by RulesAssembly.CreateModulRules instead.

Rules for building this target

Add the given Engine ThirdParty modules as static private dependencies Statically linked to this module, meaning they utilize exports from the other module Private, meaning the include paths for the included modules will not be exposed when giving this modules include paths NOTE: There is no AddThirdPartyPublicStaticDependencies function.

The target this module belongs to The names of the modules to add

Add the given Engine ThirdParty modules as dynamic private dependencies Dynamically linked to this module, meaning they do not utilize exports from the other module Private, meaning the include paths for the included modules will not be exposed when giving this modules include paths NOTE: There is no AddThirdPartyPublicDynamicDependencies function.

Rules for the target being built The names of the modules to add

Setup this module for Mesh Editor support (based on the settings in UEBuildConfiguration)

Setup this module for GameplayDebugger support

Setup this module for Iris support (based on the settings in UEBuildConfiguration)

Setup this module for Chaos Visual Debugger support (Required for recording debug data that will be visualized in the Chaos Visual Debugger tool)

Setup this module for physics support (based on the settings in UEBuildConfiguration)

Determines if a module type is valid for a target, based on custom attributes

The type of the module to check The target to check against Out, reason this module was invalid True if the module is valid, false otherwise

Determines if this module can be precompiled for the current target.

Path to the module rules file True if the module can be precompiled, false otherwise

Determines whether a given platform is available in the context of the current Target

The platform to check for True if it's available, false otherwise

Returns all the modules that are in the given module group

The name of the module group, as defined by a [ModuleGroup("Name")] attribute Only include modules that are valid for the current Target

Prepares a module for building a low level tests executable. If we're building a module as part of a test module chain, then they require the LowLevelTestsRunner dependency.

Whether this is a low level tests module.

Returns the module directory for a given subclass of the module (platform extensions add subclasses of ModuleRules to add in platform-specific settings)

typeof the subclass Directory where the subclass's .Build.cs lives, or null if not found

Returns the directories for all subclasses of this module, as well as any additional directories specified by the rules

List of directories, or null if none were added

Adds an additional module directory, if it exists (useful for NotForLicensees/NoRedist)

true if the directory exists

Returns if VcPkg is supported for the build configuration.

True if supported

Returns the VcPkg root directory for the build configuration

The name of the third-party package

Adds libraries compiled with vcpkg to the current module

The name of the third-party package Should the include directory be added to PublicIncludePaths The names of the libaries to add to PublicAdditionalLibraries/

Replace an expected value in a list of definitions with a new value

List of definitions e.g. PublicDefinitions Name of the define to change Expected value New value

Replace an expected value in a list of module names with a new value

List of module names e.g. PublicDependencyModuleNames Expected value New value

Stores information about where a module rules object came from, and how it can be used.

The scope for this module. Used to validate references to other modules.

The default directory for output files

The plugin that this module belongs to

Whether this module should be included in the default hot reload set

Whether this module should be compiled with optimization disabled in DebugGame configurations (ie. whether it's a game module).

Whether this module can be used for generating shared PCHs

Whether to treat this module as a game module for UHT ordering

The default module type for UnrealHeaderTool. Do not use this for inferring other things about the module.

Constructor

Copy constructor

The context to copy from

Read-only wrapper around an existing TargetRules instance. This exposes target settings to modules without letting them to modify the global environment.

The writeable TargetRules instance

Constructor

The TargetRules instance to wrap around

Accessors for fields on the inner TargetRules instance

Provide access to the RelativeEnginePath property for code referencing ModuleRules.BuildConfiguration.

Provide access to the UEThirdPartySourceDirectory property for code referencing ModuleRules.UEBuildConfiguration.

Provide access to the UEThirdPartyBinariesDirectory property for code referencing ModuleRules.UEBuildConfiguration.

Whether this is a low level tests target.

Whether this is a test target explicitly defined. Explicitley defined test targets always inherit from TestTargetRules and define their own tests. Implicit test targets are created from existing targets when building with -Mode=Test and they include tests from all dependencies.

Controls the value of WITH_LOW_LEVEL_TESTS that dictates whether module-specific low level tests are compiled in or not.

Get the platforms this target supports

Get the configurations this target supports

Checks if current platform is part of a given platform group

The platform group to check True if current platform is part of a platform group

Gets diagnostic messages about default settings which have changed in newer versions of the engine

List of messages to be appended to

Checks if a plugin should be programmatically allowed in the build

true if the plugin is allowed

Determines if the automation tests should be compiled based on the current configuration and optional forced settings. If either the development tests or performance tests are compiled (unless explicitly disabled), this property returns true.

PS4-specific target settings

PS5-specific target settings

Switch-specific target settings

Singleton accessor for WinGDKPlatform

Singleton accessor for XB1Platform

XboxCommon-specific target settings - directs to the platform-specific rules

Singleton accessor for XSXPlatform

Describes all of the information needed to initialize a UEBuildTarget object

Foreign plugin to compile against this target

Whether we should treat the ForeignPlugin argument as a local plugin for building purposes

When building a foreign plugin, whether to build plugins it depends on as well.

Set of module names to compile.

Lists of files to compile

Individual file(s) to compile

Relative path to file(s) to compile

Working directory when compiling with RelativePathsToSpecificFilesToCompile

Will build all files that directly include any of the files provided in -SingleFile

Whether to perform hot reload for this target

Map of module name to suffix for hot reloading from the editor

Path to a file containing a list of modules that may be modified for live coding.

Path to the manifest for passing info about the output to live coding

If a non-zero value, a live coding request will be terminated if more than the given number of actions are required.

Suppress messages about building this target

Clean the target before trying to build it

Whether to unify C++ code into larger files for faster compilation.

Whether to force C++ source files to be combined into larger files for faster compilation.

Enables "include what you use" mode.

Intermediate environment. Determines if the intermediates end up in a different folder than normal.

Constructor

Path to the project file Name of the target to build Platform to build for Configuration to build Architectures to build for Other command-line arguments for the target

Parse a list of target descriptors from the command line

Command-line arguments Build configuration to get common flags from Logger for output List of target descriptors

Parse a list of target descriptors from the command line

Command-line arguments Logger for output List of target descriptors

Parse a list of target descriptors from the command line

Command-line arguments Whether to use a precompiled engine distribution Whether to skip compiling rules assemblies Whether to always compile all rules assemblies Logger for output List of target descriptors

Parse a list of target descriptors from the command line

Command-line arguments Whether to use a precompiled engine distribution Whether to skip compiling rules assemblies Whether to always compile rules assemblies Receives the list of parsed target descriptors Logger for output

Parse a list of target descriptors from the command line

Command-line arguments Whether to use a precompiled engine distribution Whether to skip compiling rules assemblies Whether to always compile all rules assemblies List of target descriptors Logger for output

Try to parse the project file from the command line

The command line arguments The project file that was parsed True if the project file was parsed, false otherwise

Format this object for the debugger

String representation of this target descriptor

Information about a target, passed along when creating a module descriptor

Name of the target

The platform that the target is being built for

The configuration being built

Architecture that the target is being built for

Intermediate environment. Determines if the intermediates end up in a different folder than normal.

The project containing the target

The current build version

Additional command line arguments for this target

Constructs a TargetInfo for passing to the TargetRules constructor.

Name of the target being built The platform that the target is being built for The configuration being built The architectures being built for Path to the project file containing the target Additional command line arguments for this target Intermediate environment to use

Construct a TargetInfo from an archive on disk

Archive to read from

Write a TargetInfo to an archive on disk

Archive to write to

The type of target

Cooked monolithic game executable (GameName.exe). Also used for a game-agnostic engine executable (UnrealGame.exe or RocketGame.exe)

Uncooked modular editor executable and DLLs (UnrealEditor.exe, UnrealEditor*.dll, GameName*.dll)

Cooked monolithic game client executable (GameNameClient.exe, but no server code)

Cooked monolithic game server executable (GameNameServer.exe, but no client code)

Program (standalone program, e.g. ShaderCompileWorker.exe, can be modular or monolithic depending on the program)

Specifies how to link all the modules in this target

Use the default link type based on the current target type

Link all modules into a single binary

Link modules into individual dynamic libraries

Specifies whether to share engine binaries and intermediates with other projects, or to create project-specific versions. By default, editor builds always use the shared build environment (and engine binaries are written to Engine/Binaries/Platform), but monolithic builds and programs do not (except in installed builds). Using the shared build environment prevents target-specific modifications to the build environment.

Engine binaries and intermediates are output to the engine folder. Target-specific modifications to the engine build environment will be ignored.

Engine binaries and intermediates are specific to this target

Will switch to Unique if needed - per-project sdk is enabled, or a property that requires unique is set away from default

Specifies how UnrealHeaderTool should enforce member pointer declarations in UCLASSes and USTRUCTs. This should match (by name, not value) the EPointerMemberBehavior enum in BaseParser.h so that it can be interpreted correctly by UnrealHeaderTool.

Pointer members of the associated type will be disallowed and result in an error emitted from UnrealHeaderTool.

Pointer members of the associated type will be allowed and not emit any messages to log or screen.

Pointer members of the associated type will be allowed but will emit messages to log.

Determines which version of the engine to take default build settings from. This allows for backwards compatibility as new options are enabled by default.

Legacy default build settings for 4.23 and earlier.

New defaults for 4.24: * ModuleRules.PCHUsage = PCHUsageMode.UseExplicitOrSharedPCHs * ModuleRules.bLegacyPublicIncludePaths = false

New defaults for 5.2: * ModuleRules.bLegacyParentIncludePaths = false

New defaults for 5.3: * TargetRules.CppStandard = CppStandard.Default has changed from Cpp17 to Cpp20 * TargetRules.WindowsPlatform.bStrictConformanceMode = true

New defaults for 5.4: * TargetRules.bValidateFormatStrings = true

Always use the defaults for the current engine version. Note that this may cause compatibility issues when upgrading.

What version of include order to use when compiling. This controls which UE_ENABLE_INCLUDE_ORDER_DEPRECATED_IN_5_X defines are enabled when compiling the target. The UE_ENABLE_INCLUDE_ORDER_DEPRECATED_IN_5_X defines are used when removing implicit includes from Unreal Public headers. Specific versions can be used by licensees to avoid compile errors when integrating new versions of Unreal. Using Latest comes with a high risk of introducing compile errors in your code on newer Unreal versions.

Include order used in Unreal 5.1

Include order used in Unreal 5.2

Include order used in Unreal 5.3

Include order used in Unreal 5.4

Include order used in Unreal 5.5

Always use the latest version of include order. This value is updated every Unreal release, use with caution if you intend to integrate newer Unreal releases.

Contains the oldest version of include order that the engine supports. Do not delete old enum entries to prevent breaking project generation

Which static analyzer to use

Do not perform static analysis

Use the default static analyzer for the selected compiler, if it has one. For Visual Studio and Clang, this means using their built-in static analysis tools. Any compiler that doesn't support static analysis will ignore this option.

Use the built-in Visual C++ static analyzer

Use PVS-Studio for static analysis

Use clang for static analysis. This forces the compiler to clang.

Output type for the static analyzer. This currently only works for the Clang static analyzer. The Clang static analyzer can do either Text, which prints the analysis to stdout, or html, where it writes out a navigable HTML page for each issue that it finds, per file. The HTML is output in the same directory as the object file that would otherwise have been generated. All other analyzers default automatically to Text.

Output the analysis to stdout.

Output the analysis to an HTML file in the object folder.

Output type for the static analyzer. This currently only works for the Clang static analyzer. The Clang static analyzer can do a shallow quick analysis. However the default deep is recommended.

Default deep analysis.

Quick analysis. Not recommended.

Optimization mode for compiler settings

Favor speed

Favor minimal code size

Somewhere between Speed and Size

Debug info mode for compiler settings to determine how much debug info is available

Disable all debugging info. MSVC: object files will be compiled without /Z7 or /Zi but pdbs will still be created callstacks should be available in this mode but there have been reports with them being incorrect

Enable debug info for engine modules

Enable debug info for engine plugins

Enable debug info for project modules

Enable debug info for project plugins

Only include debug info for engine modules and plugins

Only include debug info for project modules and project plugins

Include full debugging information for all modules

Floating point math semantics

Use the default semantics for the platform.

FP math is IEEE-754 compliant, assuming that FP exceptions are disabled and the rounding mode is round-to-nearest-even.

FP math isn't IEEE-754 compliant: the compiler is allowed to transform math expressions in a ways that might result in differently rounded results from what IEEE-754 requires.

Determines how the Gameplay Debugger plugin will be activated.

Default => Not overriden, default usage behavior.

Core => WITH_GAMEPLAY_DEBUGGER = 0 and WITH_GAMEPLAY_DEBUGGER_CORE = 1

Full => WITH_GAMEPLAY_DEBUGGER = 1 and WITH_GAMEPLAY_DEBUGGER_CORE = 1

Utility class for EngineIncludeOrderVersion defines

Returns a list of every deprecation define available.

Get a list of every deprecation define and their value for the specified engine include order.

Returns the latest deprecation define.

Attribute used to mark fields which must match between targets in the shared build environment

Attribute used to mark configurable sub-objects

TargetRules is a data structure that contains the rules for defining a target (application/executable)

Static class wrapping constants aliasing the global TargetType enum.

Alias for TargetType.Game

Alias for TargetType.Editor

Alias for TargetType.Client

Alias for TargetType.Server

Alias for TargetType.Program

The name of this target

If the Name of this target has been overriden

Return the original target name without overrides or adornments

Override the name used for this target

Whether this is a low level tests target.

Override this boolean flag in inheriting classes for low level test targets.

Whether this is a test target explicitly defined. Explicitley defined test targets always inherit from TestTargetRules and define their own tests. Implicit test targets are created from existing targets when building with -Mode=Test and they include tests from all dependencies.

Controls the value of WITH_LOW_LEVEL_TESTS that dictates whether module-specific low level tests are compiled in or not.

Override the value of WithLowLevelTests by setting this to true in inherited classes.

File containing the general type for this target (not including platform/group)

File containing the platform/group-specific type for this target

All target files that could be referenced by this target and will require updating the Makefile if changed

Logger for output relating to this target. Set before the constructor is run from

Generic nullable object so a user can set additional data in a project's TargetRule and access in a project's ModuleRule without needing to add new properties post-release. For example: * in .Target.cs: AdditionalData = "data"; * in .Build.cs: if ((Target.AdditionalData as string) == "data") { ... }

Platform that this target is being built for.

The configuration being built.

Architecture that the target is being built for (or an empty string for the default).

Gets the Architecture in the normal case where there is a single Architecture in Architectures (this will throw an exception if there is more than one architecture specified)

Intermediate environment. Determines if the intermediates end up in a different folder than normal.

Path to the project file for the project containing this target.

The current build version

The type of target.

Specifies the engine version to maintain backwards-compatible default build settings with (eg. DefaultSettingsVersion.Release_4_23, DefaultSettingsVersion.Release_4_24). Specify DefaultSettingsVersion.Latest to always use defaults for the current engine version, at the risk of introducing build errors while upgrading.

Force the include order to a specific version. Overrides any Target and Module rules.

What version of include order to use when compiling this target. Can be overridden via -ForceIncludeOrder on the command line. ModuleRules.IncludeOrderVersion takes precedence.

Path to the output file for the main executable, relative to the Engine or project directory. This setting is only typically useful for non-UE programs, since the engine uses paths relative to the executable to find other known folders (eg. Content).

Tracks a list of config values read while constructing this target

Whether the target uses Steam.

Whether the target uses CEF3.

Whether the project uses visual Slate UI (as opposed to the low level windowing/messaging, which is always available).

Forces linking against the static CRT. This is not fully supported across the engine due to the need for allocator implementations to be shared (for example), and TPS libraries to be consistent with each other, but can be used for utility programs.

Enables the debug C++ runtime (CRT) for debug builds. By default we always use the release runtime, since the debug version isn't particularly useful when debugging Unreal Engine projects, and linking against the debug CRT libraries forces our third party library dependencies to also be compiled using the debug CRT (and often perform more slowly). Often it can be inconvenient to require a separate copy of the debug versions of third party static libraries simply so that you can debug your program's code.

Whether the output from this target can be publicly distributed, even if it has dependencies on modules that are in folders with special restrictions (eg. CarefullyRedist, NotForLicensees, NoRedist).

Specifies the configuration whose binaries do not require a "-Platform-Configuration" suffix.

Specifies the separator charcter for binary filenames.

Whether this target supports hot reload

Build all the modules that are valid for this target type. Used for CIS and making installed engine builds.

Set this to reference a VSTest run settings file from generated projects.

Additional plugins that are built for this target type but not enabled.

If this is true, then the BuildPlugins list will be used to populate RuntimeDependencies, rather than EnablePlugins

A list of additional plugins which need to be included in this target. This allows referencing non-optional plugin modules which cannot be disabled, and allows building against specific modules in program targets which do not fit the categories in ModuleHostType.

Additional plugins that should be included for this target.

List of plugins to be disabled for this target. Note that the project file may still reference them, so they should be marked as optional to avoid failing to find them at runtime.

Additional plugins that should be included for this target if they are found.

If false, suppress loading "enabled by default" engine plugins not explicitly enabled by the project or target files.

How to treat conflicts when a disabled plugin is being enabled by another plugin referencing it

A list of Plugin names that are allowed to exist as dependencies without being defined in the uplugin descriptor

Path to the set of pak signing keys to embed in the executable.

Allows a Program Target to specify it's own solution folder path.

Force a Target to be treated as a Program for the purposes of project file generation.

If true, GetTargetNameByType will not consider this target, thereby disambiguating -TargetType=X.

Whether the target should be included in the default solution build configuration Setting this to false will skip building when running in the IDE

Whether this target should be compiled as a DLL. Requires LinkType to be set to TargetLinkType.Monolithic.

Extra subdirectory to load config files out of, for making multiple types of builds with the same platform This will get baked into the game executable as CUSTOM_CONFIG and used when staging to filter files and settings

Subfolder to place executables in, relative to the default location.

Allow target module to override UHT code generation version.

Whether to enable the mesh editor.

Whether to use the BPVM to run Verse.

Whether to use the AutoRTFM Clang compiler.

Whether to use force AutoRTFM Clang compiler off.

Whether to enable emitting AutoRTFM verification metadata

Whether to compile the Chaos physics plugin.

Whether to use the Chaos physics interface. This overrides the physx flags to disable APEX and NvCloth

Whether to compile in checked chaos features for debugging

Whether to compile in chaos memory tracking features

Whether to compile in Chaos Visual Debugger (CVD) support features to record the state of the physics simulation

Whether scene query acceleration is done by UE. The physx scene query structure is still created, but we do not use it.

Whether to include PhysX support.

Whether to include PhysX APEX support.

Whether to include NvCloth.

Whether to include ICU unicode/i18n support in Core.

Whether to compile CEF3 support.

Whether to compile using ISPC.

Whether to compile IntelMetricsDiscovery.

Whether to compile in python support

Whether to compile with WITH_GAMEPLAY_DEBUGGER enabled with all Engine's default gameplay debugger categories.

Set to true when bUseGameplayDebugger is false but GameplayDebugger's core parts are required.

Whether to use I/O store on-demand

Whether to use Iris.

Whether to track owner (asset name) of RHI resource for Test configuration. Useful for ListShaderMaps and ListShaderLibraries commands.

Whether we are compiling editor code or not. Prefer the more explicit bCompileAgainstEditor instead.

Whether to compile code related to building assets. Consoles generally cannot build assets. Desktop platforms generally can.

Whether to compile WITH_EDITORONLY_DATA disabled. Only Windows will use this, other platforms force this to false.

Manually specified value for bBuildDeveloperTools.

Whether to compile the developer tools.

Manually specified value for bBuildTargetDeveloperTools.

Whether to compile the developer tools that are for target platforms or connected devices (defaults to bBuildDeveloperTools)

Whether to force compiling the target platform modules, even if they wouldn't normally be built.

Whether to force compiling shader format modules, even if they wouldn't normally be built.

Override for including extra shader formats

Whether we should include any extra shader formats. By default this is only enabled for Program and Editor targets.

Checks the above flags to see if target SDKs are likely to be compiled in

Whether we should compile SQLite using the custom "Unreal" platform (true), or using the native platform (false).

Whether to utilize cache freed OS allocs with MallocBinned

Enabled for all builds that include the engine project. Disabled only when building standalone apps that only link with Core.

Enabled for all builds that include the CoreUObject project. Disabled only when building standalone apps that only link with Core.

Enabled for builds that need to initialize the ApplicationCore module. Command line utilities do not normally need this.

Enabled for builds that want to use against the Trace module for profiling and diagnostics.

Force enable tracing - used to allow testing programs to verify tracing works as intended.

Manually specified value for bCompileAgainstEditor.

Enabled for editor builds (TargetType.Editor). Can be overridden for programs (TargetType.Program) that would need to compile against editor code. Not available for other target types. Mainly drives the value of WITH_EDITOR.

Whether to compile Recast navmesh generation.

Whether to compile with navmesh segment links.

Whether to compile with navmesh cluster links.

Whether to compile SpeedTree support.

Whether we should compile in support for SpeedTree or not.

Enable exceptions for all modules.

Enable inlining for all modules.

Enable exceptions for all modules.

Enable RTTI for all modules.

Enable BuildSettings to contain private information about build. Such as machine name, user name and user domain name (exposed in BuildSettings.h)

Enable Position Independent Executable (PIE). Has an overhead cost

Enable Stack Protection. Has an overhead cost

Compile client-only code.

Compile server-only code.

Compile with FName storing the number part in the name table. Saves memory when most names are not numbered and those that are are referenced multiple times. The game and engine must ensure they reuse numbered names similarly to name strings to avoid leaking memory.

When enabled, Push Model Networking support will be compiled in. This can help reduce CPU overhead of networking, at the cost of more memory. Always enabled in editor builds.

Whether to include stats support even without the engine.

Whether to include plugin support.

Whether to allow plugins which support all target platforms.

Whether to allow accessibility code in both Slate and the OS layer.

Whether to include PerfCounters support.

Whether to enable support for live coding

Whether to enable support for live coding

Whether to enable support for DirectX Math LWC_TODO: No longer supported. Needs removing.

Whether to enable the support for FixedTimeStep in the engine

Whether to turn on logging for test/shipping builds.

Whether to turn on console for shipping builds.

Whether to turn on logging to memory for test/shipping builds.

Whether to check that the process was launched through an external launcher.

Whether to turn on checks (asserts) for test/shipping builds.

Whether to turn on GPU markers for Test builds.

Whether to turn on GPU markers for Shipping builds.

Whether to turn on UTF-8 mode, mapping TCHAR to UTF8CHAR.

Whether to use the EstimatedUtcNow or PlatformUtcNow. EstimatedUtcNow is appropriate in cases where PlatformUtcNow can be slow.

True if we need FreeType support.

Whether to turn allow exec commands for shipping builds.

True if we want to favor optimizing size over speed.

Allows to fine tune optimizations level for speed and\or code size

Allows setting the FP semantics.

Whether to compile development automation tests.

Whether to compile performance automation tests.

Whether to override the defaults for automation tests (Debug/Development configs)

If true, event driven loader will be used in cooked builds. @todoio This needs to be replaced by a runtime solution after async loading refactor.

Used to override the behavior controlling whether UCLASSes and USTRUCTs are allowed to have native pointer members, if disallowed they will be a UHT error and should be substituted with TObjectPtr members instead.

Whether the XGE controller worker and modules should be included in the engine build. These are required for distributed shader compilation using the XGE interception interface.

Enables "include what you use" by default for modules in this target. Changes the default PCH mode for any module in this project to PCHUsageMode.UseExplicitOrSharedPCHs.

Adds header files in included modules to the build.

When used with -IncludeHeaders, only header files will be compiled.

Enforce "include what you use" rules; warns if monolithic headers (Engine.h, UnrealEd.h, etc...) are used, and checks that source files include their matching header first.

Emit a warning when an old-style monolithic header is included while compiling this target.

Whether the final executable should export symbols.

Make static libraries for all engine modules as intermediates for this target.

Whether we should compile with support for OS X 10.9 Mavericks. Used for some tools that we need to be compatible with this version of OS X.

True if this is a console application that's being built.

If true, creates an additional console application. Hack for Windows, where it's not possible to conditionally inherit a parent's console Window depending on how the application is invoked; you have to link the same executable with a different subsystem setting.

If true, only creates an additional console application. Overrides bBuildAdditionalConsoleApp.

True if debug symbols that are cached for some platforms should not be created.

Whether to unify C++ code into larger files for faster compilation.

Whether to unify C++ code into larger files for faster compilation.

Whether to force C++ source files to be combined into larger files for faster compilation.

Whether to merge module and generated unity files for faster compilation.

List of modules that disables merging module and generated cpp files in the same unity files.

Use a heuristic to determine which files are currently being iterated on and exclude them from unity blobs, result in faster incremental compile times. The current implementation uses the read-only flag to distinguish the working set, assuming that files will be made writable by the source control system if they are being modified. This is true for Perforce, but not for Git.

Disable optimization for files that are in the adaptive non-unity working set.

Disables force-included PCHs for files that are in the adaptive non-unity working set.

Backing storage for bAdaptiveUnityDisablesProjectPCH.

Whether to disable force-included PCHs for project source files in the adaptive non-unity working set. Defaults to bAdaptiveUnityDisablesPCH;

Creates a dedicated PCH for each source file in the working set, allowing faster iteration on cpp-only changes.

Creates a dedicated PCH for each source file in the working set, allowing faster iteration on cpp-only changes.

Creates a dedicated source file for each header file in the working set to detect missing includes in headers.

The number of source files in a game module before unity build will be activated for that module. This allows small game modules to have faster iterative compile times for single files, at the expense of slower full rebuild times. This setting can be overridden by the bFasterWithoutUnity option in a module's Build.cs file.

Default treatment of uncategorized warnings

Require TObjectPtr for FReferenceCollector API's. (Needed for compatibility with incremental GC.)

Emits compilation errors for incorrect UE_LOG format strings.

Level to report deprecation warnings as errors

Forces shadow variable warnings to be treated as errors on platforms that support it.

Whether to enable all warnings as errors. UE enables most warnings as errors already, but disables a few (such as deprecation warnings).

Indicates what warning/error level to treat unsafe type casts as on platforms that support it (e.g., double->float or int64->int32)

Forces the use of undefined identifiers in conditional expressions to be treated as errors.

Indicates what warning/error level to treat undefined identifiers in conditional expressions.

Indicates what warning/error level to treat potential PCH performance issues.

How to treat general module include path validation messages

How to treat private module include path validation messages, where a module is adding an include path that exposes private headers

How to treat unnecessary module sub-directory include path validation messages

Print out files that are included by each source file

Forces frame pointers to be retained this is usually required when you want reliable callstacks e.g. mallocframeprofiler

Forces frame pointers to be retained this is usually required when you want reliable callstacks e.g. mallocframeprofiler

New Monolithic Graphics drivers have optional "fast calls" replacing various D3d functions

An approximate number of bytes of C++ code to target for inclusion in a single unified C++ file.

Disables overrides that are set by the module

Whether to stress test the C++ unity build robustness by including all C++ files files in a project from a single unified file.

Whether to add additional information to the unity files, such as '_of_X' in the file name. Not recommended.

Whether to force debug info to be generated.

Whether to globally disable debug info generation; Obsolete, please use TargetRules.DebugInfoMode instead

How much debug info should be generated. See DebugInfoMode enum for more details

Modules that should have debug info disabled

Plugins that should have debug info disabled

True if only debug line number tables should be emitted in debug information for compilers that support doing so. Overrides TargetRules.DebugInfo See https://clang.llvm.org/docs/UsersManual.html#cmdoption-gline-tables-only for more information

Modules that should emit line number tables instead of full debug information for compilers that support doing so. Overrides DisableDebugInfoModules

Plugins that should emit line number tables instead of full debug information for compilers that support doing so. Overrides DisableDebugInfoPlugins

Whether to disable debug info generation for generated files. This improves link times and reduces pdb size for modules that have a lot of generated glue code.

Whether to disable debug info on PC/Mac in development builds (for faster developer iteration, as link times are extremely fast with debug info disabled).

Whether PDB files should be used for Visual C++ builds.

Whether PCH files should be used.

Set flags require for deterministic compiling and linking. Enabling deterministic mode for msvc disables codegen multithreading so compiling will be slower

Whether PCHs should be chained when compiling with clang.

Whether PCH headers should be force included for gen.cpp files when PCH is disabled.

Whether to just preprocess source files for this target, and skip compilation

Generate dependency files by preprocessing. This is only recommended when distributing builds as it adds additional overhead.

Whether to generate assembly data while compiling this target. Works exclusively on MSVC for now.

Experimental: Store object (.obj) compressed on disk. Requires UBA to link, currently MSVC only. Toggling this flag will invalidate MSVC actions. Warning, this option is not currently compatitable with PGO or the the cl-clang linker as those are not detoured and linking will fail.

Whether static code analysis should be enabled.

The output type to use for the static analyzer. This is only supported for Clang.

The mode to use for the static analyzer. This is only supported for Clang. Shallow mode completes quicker but is generally not recommended.

The level of warnings to print when analyzing using PVS-Studio

Only run static analysis against project modules, skipping engine modules

When enabled, generated source files will be analyzed

The minimum number of files that must use a pre-compiled header before it will be created and used.

When enabled, a precompiled header is always generated for game modules, even if there are only a few source files in the module. This greatly improves compile times for iterative changes on a few files in the project, at the expense of slower full rebuild times for small game projects. This can be overridden by setting MinFilesUsingPrecompiledHeaderOverride in a module's Build.cs file.

Whether to use incremental linking or not. Incremental linking can yield faster iteration times when making small changes. Currently disabled by default because it tends to behave a bit buggy on some computers (PDB-related compile errors).

Whether to allow the use of link time code generation (LTCG).

When Link Time Code Generation (LTCG) is enabled, whether to prefer using the lighter weight version on supported platforms.

Directory where to put the ThinLTO cache on supported platforms.

Arguments that will be applied to prune the ThinLTO cache on supported platforms. Arguments will only be applied if ThinLTOCacheDirectory is set.

Whether to enable Profile Guided Optimization (PGO) instrumentation in this build.

Whether to optimize this build with Profile Guided Optimization (PGO).

Whether the target requires code coverage compilation and linking.

Whether to support edit and continue.

Whether to omit frame pointers or not. Disabling is useful for e.g. memory profiling on the PC.

If we want to compress the debug files

Whether to enable support for C++20 modules

Whether to enable support for C++20 coroutines This option is provided to facilitate evaluation of the feature. Expect the name of the option to change. Use of coroutines in with UE is untested and unsupported.

Whether to enable engine's ability to set process priority on runtime. This option requires some environment setup on Linux, that's why it's disabled by default. Project has to opt-in this feature as it has to guarantee correct setup.

If true, then enable memory profiling in the build (defines USE_MALLOC_PROFILER=1 and forces bOmitFramePointers=false).

If true, then enable Unreal Insights (utrace) profiling in the build for the Shader Compiler Worker (defines USE_SHADER_COMPILER_WORKER_TRACE=1).

Enables "Shared PCHs", a feature which significantly speeds up compile times by attempting to share certain PCH files between modules that UBT detects is including those PCH's header files.

True if Development and Release builds should use the release configuration of PhysX/APEX.

True if Development and Release builds should use the checked configuration of PhysX/APEX. if bUseShippingPhysXLibraries is true this is ignored.

Tells the UBT to check if module currently being built is violating EULA.

Tells the UBT to break build if module currently being built is violating EULA.

Whether to use the :FASTLINK option when building with /DEBUG to create local PDBs on Windows. Fast, but currently seems to have problems finding symbols in the debugger.

Outputs a map file as part of the build.

True if runtime symbols files should be generated as a post build step for some platforms. These files are used by the engine to resolve symbol names of callstack backtraces in logs.

Package full path (directory + filename) where to store input files used at link time Normally used to debug a linker crash for platforms that support it

Directory where to put crash report files for platforms that support it

Bundle version for Mac apps.

Whether to deploy the executable after compilation on platforms that require deployment.

Whether to force skipping deployment for platforms that require deployment by default.

When enabled, allows XGE to compile pre-compiled header files on remote machines. Otherwise, PCHs are always generated locally.

Will replace pch with ifc and use header units instead. This is an experimental and msvc-only feature

Whether headers in system paths should be checked for modification when determining outdated actions.

Whether to disable linking for this target.

Whether to ignore tracking build outputs for this target.

Whether to disable UE_DEPRECATED_FORENGINE deprecation warnings in non-engine modules. This should only be used in the short-term as these deprecations will get removed.

Indicates that this is a formal build, intended for distribution. This flag is automatically set to true when Build.version has a changelist set and is a promoted build. The only behavior currently bound to this flag is to compile the default resource file separately for each binary so that the OriginalFilename field is set correctly. By default, we only compile the resource once to reduce build times.

Whether to clean Builds directory on a remote Mac before building.

Whether to write detailed timing info from the compiler and linker.

Whether to parse timing data into a tracing file compatible with chrome://tracing.

Whether to expose all symbols as public by default on POSIX platforms

Disable supports for inlining gen.cpps

Allows overriding the toolchain to be created for this target. This must match the name of a class declared in the UnrealBuildTool assembly.

The weight(cpu/memory utilization) of a MSVC compile action

The weight(cpu/memory utilization) of a clang compile action

Whether to allow engine configuration to determine if we can load unverified certificates.

Whether to load generated ini files in cooked build, (GameUserSettings.ini loaded either way)

Whether to load non-ufs ini files in cooked build, (GameUserSettings.ini loaded either way)

Add all the public folders as include paths for the compile environment.

Add all the parent folders as include paths for the compile environment.

Which C++ standard to use for compiling this target (for engine modules)

Which C++ standard to use for compiling this target (for non-engine modules)

Which C standard to use for compiling this target

Direct the compiler to generate AVX instructions wherever SSE or AVX intrinsics are used, on the x64 platforms that support it. Ignored for arm64. Note that by enabling this you are changing the minspec for the target platform, and the resultant executable will crash on machines without AVX support.

Do not allow manifest changes when building this target. Used to cause earlier errors when building multiple targets with a shared build environment.

The build version string

Specifies how to link modules in this target (monolithic or modular). This is currently protected for backwards compatibility. Call the GetLinkType() accessor until support for the deprecated ShouldCompileMonolithic() override has been removed.

Experimental: Strip unused exports from libraries. Only applies when LinkType is Modular

Experimental: Merge modular modules into combined libraries. Sets LinkType to Modular and enables bStripExports

Experimental: List of plugins (and their dependencies) to each merge into separate libraries. Requires bMergeModules to be enabled

Experimental: List of merged plugins to move common dependencies to a shared library, requires MergePlugins. Can be chained

Experimental: List of merged plugins to move to the main executable, requires MergePlugins. "Engine" for all shared engine modules and "Common" for shared project modules.

Backing storage for the LinkType property.

Macros to define globally across the whole target.

Macros to define across all macros in the project.

Specifies the name of the launch module. For modular builds, this is the module that is compiled into the target's executable.

Backing storage for the LaunchModuleName property.

Specifies the path to write a header containing public definitions for this target. Useful when building a DLL to be consumed by external build processes.

List of additional modules to be compiled into the target.

Path to a manifest to output for this target

Path to a list of dependencies for this target, when precompiling

Backing storage for the BuildEnvironment property

Specifies the build environment for this target. See TargetBuildEnvironment for more information on the available options.

If this true, a Shared build environment target will allow for any modules that are SDK version sensitive to have a project side module when an SDK is overridden. For instance, if IOSTargetPlatform, which is marked as IOS SDK version relevant, is compiled for a Target with this set to true, and that target overrides the IOS SDK, then this would compile to e.g. MyProject/Binaries/Win64/IOS/MyProject-IOSTargetPlatform.dll

Whether to ignore violations to the shared build environment (eg. editor targets modifying definitions)

Specifies a list of targets which should be built before this target is built.

Specifies a list of steps which should be executed before this target is built, in the context of the host platform's shell. The following variables will be expanded before execution: $(EngineDir), $(ProjectDir), $(TargetName), $(TargetPlatform), $(TargetConfiguration), $(TargetType), $(ProjectFile).

Specifies a list of steps which should be executed after this target is built, in the context of the host platform's shell. The following variables will be expanded before execution: $(EngineDir), $(ProjectDir), $(TargetName), $(TargetPlatform), $(TargetConfiguration), $(TargetType), $(ProjectFile).

Specifies additional build products produced as part of this target.

Additional arguments to pass to the compiler

Additional arguments to pass to the linker

Max amount of memory that each compile action may require. Used by ParallelExecutor to decide the maximum number of parallel actions to start at one time.

List of modules to disable unity builds for

List of modules to enable optimizations for

List of modules to disable optimizations for

List of modules to optimize for size. This allows the target to override module optimization level Note that this may disable PCH usage if a private PCH is not provided

List of modules to optimize for size and speed. This allows the target to override module optimization level Note that this may disable PCH usage if a private PCH is not provided

When generating project files, specifies the name of the project file to use when there are multiple targets of the same type.

If this is non-null, then any platforms NOT listed will not be allowed to have modules in their directories be created

Android-specific target settings.

IOS-specific target settings.

Linux-specific target settings.

Mac-specific target settings.

Windows-specific target settings.

Checks if the target needs to care about sdk version - if not, we can share the target between projects that are on differnet sdk versions. For instance, ShaderCompileWorker is very tied to, say, console sdk versions, but UnrealPak doesn't have sdk things compiled in

Allow a target to override whether or not AreSDKVersionsRelevant uses default logic

Checks if the target can use non-standard sdk versions. For instance, the editor is usually compiled as a modular build shared between projects, so if one projet uses sdk version 1, and another uses 2, then the generated engine modules will use the most recently built sdk, which could break

Checks if a plugin should be programmatically allowed in the build

true if the plugin is allowed

Checks if a property has been set with the RequiresUniqueBuildEnvironmentAttribute, and is different from it's base

Assembly containing the target Commandline options that may affect the target creation If the target requires a unique build environment, this will contain the names of the field/property that require unique, mapped to a pair of base and current value If the target requires a unique build environment, this will contain the name of the target this was based on (UnrealGame, UnrealEditor, etc)/property true if a property was set such that it requires a unique build environment

For any target that has set BuildEnvironment = TargetBuildEnvironment.Unique, this will change the Environment to either Shared or Unique accordingly

Assembly containing the target Commandline options that may affect the target creation Logger

Create a TargetRules instance

Type to create Target info Path to the file for the rules assembly Path to the platform specific rules file Path to all possible rules file Logger for the new target rules Target instance

Constructor.

Information about the target being built

Formats an array of bytes as a sequence of values

The data to convert into a string List of hexadecimal bytes

Override any settings required for the selected target type

Override settings that all cooked editor targets will want

Gets a list of platforms that this target supports

Array of platforms that the target supports

Gets a list of configurations that this target supports

Array of configurations that the target supports

Finds all the subobjects which can be configured by command line options and config files

Sequence of objects

Gets the host platform being built on

Expose the bGenerateProjectFiles flag to targets, so we can modify behavior as appropriate for better intellisense

Indicates whether target rules should be used to explicitly enable or disable plugins. Usually not needed for project generation unless project files indicate whether referenced plugins should be built or not.

Expose a setting for whether or not the engine is installed

Flag for whether the engine is installed

Gets diagnostic messages about default settings which have changed in newer versions of the engine

List of diagnostic messages

Prints diagnostic messages about default settings which have changed in newer versions of the engine

PS4-specific target settings.

PS5-specific target settings.

Switch-specific target settings.

WinGDK-specific target settings.

XB1-specific target settings.

XboxCommon-specific target settings - directs to the platform-specific rules

XSX-specific target settings.

ModuleRules extension for low level tests.

Check if running in test mode.

Associated tested module of this test module.

Test metadata, used with BuildGraph only.

Constructs a TestModuleRules object as its own test module.

Constructs a TestModuleRules object as its own test module. Sets value of bUsesCatch2.

Constructs a TestModuleRules object with an associated tested module.

Set test-specific resources folder relative to module directory. This will be copied to the binaries path during deployment.

Deprecated, test metadata now generated explicitly using -Mode-Test with -GenerateMetadata.

Generates or updates metadata file for LowLevelTests.xml containing test flags: name, short name, target name, relative binaries path, supported platforms etc. Called by RunUBT.bat -Mode=Test -GenerateMetadata

Test metadata class.

Test long name.

Test short name used for display in build system.

Type of Catch2 report, defaults to console.

Does this test use project files for staging additional files and cause the build to use BuildCookRun instead of a Compile step

Is this test deactivated?

Depercated, use GauntletArgs or ExtraArgs instead to help indicate arguments to launch the test under.

Any initial Gauntlet args to be passed to the test executable

Any extra args to be passed to the test executable as --extra-args

Whether there's a step that gets executed after the tests have finished. Typically used for cleanup of resources.

Test built with a frakework other than Catch2

Set of supported platforms.

Per-platform tags.

Per-platform gauntlet args.

Per-platform extra compilation arguments.

List of platforms that cannot run tests.

Whether or not the test is run inside a Docker container for a given platform.

TargetRules extension for low level tests.

Configuration mapping to control build graph test metadata generation during project files generation.

Keeps track if low level tests executable must build with the Editor.

Keeps track if low level tests executable must build with the Engine.

Keeps track if low level tests executable must build with the ApplicationCore.

Keeps track if low level tests executable must build with the CoreUObject.

Associated tested target of this test target, if defined.

Test target override for bCompileAgainstApplicationCore. It is set to true if there is any reference to ApplicationCore in the dependency graph.

If set to true, it will not compile against ApplicationCore even if "ApplicationCore" is in the dependency graph.

Test target override for bCompileAgainstCoreUObject. It is set to true if there is any reference to CoreUObject in the dependency graph.

If set to true, it will not compile against CoreUObject even if "CoreUObject" is in the dependency graph.

Test target override for bCompileAgainstEngine. It is set to true if there is any reference to Engine in the dependency graph.

If set to true, it will not compile against engine even if "Engine" is in the dependency graph.

Test target override for bCompileAgainstEditor. It is set to true if there is any reference to UnrealEd in the dependency graph.

If set to true, it will not compile against editor even if "UnrealEd" is in the dependency graph.

Whether to stub the platform file.

Whether to mock engine default instances for materials, AI controller etc.

Constructor that explicit targets can inherit from.

Constructs a valid TestTargetRules instance from an existent TargetRules instance.

Constructor for TestTargetRules based on existing target a.k.a Implicit test target. TestTargetRules is setup as a program and is linked monolithically. It removes a lot of default compilation behavior in order to produce a minimal test environment.

All binary types generated by UBT

An executable

A dynamic library (.dll, .dylib, or .so)

A static library (.lib or .a)

Object files

Precompiled header

A binary built by UBT.

The type of binary to build

Output directory for this binary

The output file path. This must be set before a binary can be built using it.

Returns the OutputFilePath if there is only one entry in OutputFilePaths

The intermediate directory for this binary. Modules should create separate intermediate directories below this. Must be set before a binary can be built using it.

If true, build exports lib

If true, create a separate import library

If true, creates an additional console application. Hack for Windows, where it's not possible to conditionally inherit a parent's console Window depending on how the application is invoked; you have to link the same executable with a different subsystem setting.

If true, replaces the executable with a console application. Hack for Windows, where it's not possible to conditionally inherit a parent's console Window depending on how the application is invoked

The primary module that this binary was constructed for. For executables, this is typically the launch module.

List of modules to link together into this executable

Cached list of dependent link libraries.

Expanded list of runtime dependencies generated by calling PrepareRuntimeDependencies.

If compiled objects will have unused exports stripped, only affects objects compiled into modular libraries.

List of all objects that would be linked.

Create an instance of the class with the given configuration data

Creates all the modules referenced by this target.

Expands all of the runtime dependencies.

Output directory for the executable

Builds the binary.

Rules for the target being built The toolchain which to use for building The environment to compile the binary in The environment to link the binary in The working set of source files Directory containing the output executable The graph being built Logger for output Set of built products

Gets all the runtime dependencies Copies all the runtime dependencies from any modules in

The output list of runtime dependencies, mapping target file to type Map of target files to source files that need to be copied

Called to allow the binary to modify the link environment of a different binary containing a module that depends on a module in this binary.

The link environment of the dependency

Called to allow the binary to find game modules.

The OnlyModule if found, null if not

Generates a list of all modules referenced by this binary

True if dynamically loaded modules (and all of their dependent modules) should be included. True if circular dependencies should be process List of all referenced modules

Generates a list of all modules referenced by this binary

Map of module to the module that referenced it List of all referenced modules

Sets whether to create a separate import library to resolve circular dependencies for this binary

True to create a separate import library

Adds a module to the binary.

The module to add

Gets all build products produced by this binary

The target being built The platform toolchain Mapping of produced build product to type Whether debug info is enabled for this binary

Adds a build product and its associated debug file to a receipt.

Build product to add The type of built product Extensions for the matching debug file (may be null). Map of build products to their type The toolchain used to build these binaries Whether creating debug info is enabled

Enumerates resources which the toolchain may need may produced additional build products from. Some platforms (eg. Mac, Linux) can link directly against .so/.dylibs, but they are also copied to the output folder by the toolchain.

List to which libraries required by this module are added List of bundle resources required by this module

Helper function to get the console app BinaryName-Cmd.exe filename based on the binary filename.

Full path to the binary exe.

Checks whether the binary output paths are appropriate for the distribution level of its direct module dependencies

Write information about this binary to a JSON file

Writer for this binary's data

ToString implementation

Returns the OutputFilePath for this binary

Base class to handle deploy of a target for a given platform

Prepare the target for deployment

Receipt for the target being deployed True if successful, false if not

Represents a Mac/IOS framework

The name of this framework

Path to a zip file containing the framework. May be null.

Path where the zip should be extracted. May be null.

Base path to the framework on disk.

Link the framework libraries into the executable

Copy the framework to the target's Framework directory

File created after the framework has been extracted. Used to add dependencies into the action graph, used by Modern Xcode as well

For legacy xcode projects, we unzip in UBT (isntead of xcode), so we track if we've made an action for this framework yet (if two modules use the same framework, we only want to unzip it once. Other than time waste, there could be conflicts

List of variants contained in this XCFramework. Only non null for XCFrameworks

Constructor

The framework name

Constructor

The framework name Path to the zip file for this framework/xcframework Path for the extracted zip file Link the framework into the executable Copy the framework to the target's Framework directory Logger for diagnostic output

Constructor

The framework name Path for the framework/xcframework on disk Link the framework into the executable Copy the framework to the target's Framework directory Logger for diagnostic output

Gets the framework directory for given build settings

Logger for diagnostic output

Loads XCFramework variants description from Info.plist file inside XCFramework structure Logger for diagnostic output

Loads XCFramework variants description from Info.plist file inside the zipped XCFramework structure Logger for diagnostic output

Loads XCFramework variants description from Info.plist inside XCFramework structure loaded in a XmlDocument XmlDocument containing Info.plist that defines the xcframework settings Logger for diagnostic output

Represents a XCFramework variant description

Identifier of this framework variant. Is in the form platform-architectures-platformvariant. Some examples would be ios-arm64, ios-arm64_x86_64-simulator It also represents the relative path inside the XCFramefork where the Framework for this variant resides

Relative path where framework lives after applying LibraryIdentifier path

List of supported architectures for this Framework variants

Platform this Framework variant is intended for. Possible values are ios, macos, watchos, tvos

Platform variant for this Framework variant. It can be empty or any other value representing a platform variane, like maccatalyst or simulator

Constructor

Returns wether this variant is a match for given platform and architecture

Creates a XCFrameworkVariantEntry by parsing the content from the XCFramework Info.plist file

XmlNode loaded form Info.plist containing the representation of a <dict> that contains the variant description Logger for diagnostic output

Parses the content from a string value node in a plist file

XmlNode we expect to contain a <string> value Logger for diagnostic output

Parses the content from an array value node in a plist file that has several string entries

XmlNode we expect to contain a <array> value with several <string> entries Logger for diagnostic output

A unit of code compilation and linking.

The rules for this module

The directory for this module's object files

The directory for this module's generated files that are architecture independent

The name that uniquely identifies the module.

Path to the module directory

Paths to all potential module source directories (with platform extension directories added in)

The name of the .Build.cs file this module was created from, if any

The binary the module will be linked into for the current target. Only set after UEBuildBinary.BindModules is called.

The name of the _API define for this module

Set of all the public definitions

Set of all public include paths

Set of all internal include paths

Nested public include paths which used to be added automatically, but are now only added for modules with bNestedPublicIncludePaths set.

Parent include paths which used to be added automatically, but are now only added for modules with bLegacyParentIncludePaths set.

Set of all private include paths

Set of all system include paths

Set of all additional libraries

Set of all system libraries

Set of all public system library paths

Set of additional frameworks

Names of modules with header files that this module's public interface needs access to.

Names of modules that this module's public interface depends on.

Names of DLLs that this module should delay load

Names of modules with header files that this module's private implementation needs access to.

Names of modules that this module's private implementation depends on.

Extra modules this module may require at run time

Set of modules that have referenced this module

Set of all allowed restricted folder references

Set of aliased restricted folder references

Per-architecture lists of dependencies for linking to ignore (useful when building for multiple architectures, and a lib only is needed for one architecture), it's up to the Toolchain to use this

The Verse source code directory associated with this module if any

If this module has Verse code associated with it (convenience function)

If this module or any of its dependencies has Verse code associated with it

Set of debug visualizer paths

Constructor

Rules for this module Intermediate directory for this module Intermediate directory for this module for files that are architecture independent Logger for output

Log a warning or throw an error message

Determines if a file is part of the given module

Path to the file True if the file is part of this module

Returns a list of this module's dependencies.

An enumerable containing the dependencies of the module.

Returns a list of this module's frameworks.

A List containing the frameworks this module requires.

Returns a list of this module's immediate dependencies.

An enumerable containing the dependencies of the module.

Converts an optional string list parameter to a well-defined hash set.

Converts an optional string list parameter to a well-defined hash set.

Determines whether this module has a circular dependency on the given module

Enumerates additional build products which may be produced by this module. Some platforms (eg. Mac, Linux) can link directly against .so/.dylibs, but they are also copied to the output folder by the toolchain.

List to which libraries required by this module are added List of bundle resources required by this module

Determines the distribution level of a module based on its directory and includes.

The set of additional paths to check, if available Map of the restricted folder types to the first found instance

Finds all the directories that this folder references when building

Set of directories to add to

Find all the modules which affect the private compile environment.

Find all the modules which affect the public compile environment.

Find all the modules which affect the public compile environment. Searches through

Add definitions from source to target. This code also reformats defines to match strict rules which does not allow space before and after '='

Sets up the environment for compiling any module that includes the public interface of this module.

Sets up the environment for compiling this module.

Expand path variables within the context of this module

Path to expand variables within Directory containing the binary that links this module. May be mull. Directory containing the output executable. May be null. The path with variables expanded

Match a variable name within a path

The path variable Start index of the substring to match End index of the substring to match Variable name to compare against True if the variable name matches

Expand path variables within the context of this module

Path to expand variables within Directory containing the binary that links this module. May be mull. Directory containing the output executable. May be null. The path with variables expanded

Sets up the environment for linking any module that includes the public interface of this module.

Sets up the environment for linking this module.

Compiles the module, and returns a list of files output by the compiler.

Finds the modules referenced by this module which have not yet been bound to a binary

List of unbound modules

Gets all of the modules referenced by this module

Hash of all referenced modules with their addition index. Hashset used to ignore modules which are already added to the list True if dynamically loaded modules (and all of their dependent modules) should be included. True if circular dependencies should be processed True to return only this module's direct dependencies

Gathers all the module dependencies a PCH would have

Whether to include private modules. True if circular dependencies should be processed

Internal function that gathers all the module dependencies a PCH would have

Hash of all referenced modules with their addition index. Hashset used to ignore modules which are already added to the list Whether to include private modules. True if circular dependencies should be processed

Public entry point to recursively create a module and all its dependencies

Creates all the modules required for this target

Delegate to create a module with a given name Chain of references before reaching this module Stack of module dependencies that led to this module Logger for output

Public entry point to validate a module

Recursively check a module for circular dependencies

Chain of references before reaching this module Stack of module dependencies that led to this module Logger for output

Returns valueless API defines (like MODULE_API)

Write information about this binary to a JSON file

The output directory for the binary containing this module The output directory for the target executable Writer for this binary's data

Write an array of module names to a JSON writer

Writer for the array data Name of the array property Sequence of modules to write. May be null.

Write an array of strings to a JSON writer

Writer for the array data Name of the array property Sequence of strings to write. May be null.

Returns a copy of Nodes sorted by dependency. Independent or circularly-dependent nodes should remain in their same relative order within the original Nodes sequence.

The list of nodes to sort.

A module that is compiled from C++ code.

Stores a list of all source files, of different types

Instance where a CPP file doesn't include the expected header as the first include.

If UHT found any associated UObjects in this module's source files

The directory for this module's generated code

The directory for this module's generated UHT code

The directory for this module's generated VNI code

Global override to force all include paths to be always added

Paths containing *.gen.cpp files for this module. If this is null then this module doesn't have any generated code.

List of invalid include directives. These are buffered up and output before we start compiling.

Set of source directories referenced during a build

Verse source code directory associated with this module

The Verse source code directory associated with this module if any

List of allowed circular dependencies. Please do NOT add new modules here; refactor to allow the modules to be decoupled instead.

Determines if a file is part of the given module

Path to the file True if the file is part of this module

Add the default include paths for this module to its settings

Enumerates legacy include paths under a given base directory

The directory to start from. This directory is not added to the output list. Set of folder names to exclude from the search. List populated with the discovered directories

Path to the precompiled manifest location

Sets up the environment for compiling any module that includes the public interface of this module.

Gets the list of module dependencies that this module declares and then tries to optimize the list to what is actually used by the header.

Compile environment for this PCH PCH header file Logger for output Returns an optimized list of modules this module's shared PCH uses

Create a shared PCH template for this module, which allows constructing shared PCH instances in the future

The target which owns this module Base compile environment for this target Logger for output Template for shared PCHs

Creates a precompiled header action to generate a new pch file

The toolchain to generate the PCH List of actions to be executed. Additional actions will be added to this list. The created PCH instance.

Generates a precompiled header instance from the given template, or returns an existing one if it already exists

The toolchain being used to build this module The PCH template Compile environment for the current module List of actions to be executed. Additional actions will be added to this list. Instance of a PCH

Determines if a module compile environment is compatible with the given shared PCH compile environment

The module compile environment The shared PCH compile environment True if the two compile enviroments are compatible

Gets the unique suffix for a shared PCH

The shared PCH compile environment The base compile environment The unique suffix for the shared PCH

Copy settings from the module's compile environment into the environment for the shared PCH

The module compile environment The shared PCH compile environment

Compiles the provided CPP unity files. Will

Configure precompiled headers for this module

The target being built The toolchain to build with The current compile environment List of files that will be linked for the target List of build actions Logger for output

Creates a header file containing all the preprocessor definitions for a compile environment, and force-include it. We allow a more flexible syntax for preprocessor definitions than is typically allowed on the command line (allowing function macros or double-quote characters, for example). Ensuring all definitions are specified in a header files ensures consistent behavior.

The compile environment Directory to create the intermediate file Suffix for the included file The action graph being built

Creates header files from ISPC for inclusion and adds them as dependencies.

The toolchain to generate the PCH Compile environment List of ISPC source files Directory to create the intermediate file List of actions to be executed. Additional actions will be added to this list.

Create a header file containing the module definitions, which also includes the PCH itself. Including through another file is necessary on Clang, since we get warnings about #pragma once otherwise, but it also allows us to consistently define the preprocessor state on all platforms.

The output file to create File containing definitions required by the PCH The PCH file to include The action graph builder FileItem for the created file

Write a list of macro definitions to an output file

Additional context to add to generated comment List of includes List of definitions List of definitions to undefine Writer to receive output

Checks that the first header included by the source files in this module all include the same header

The target being compiled Compile environment for the module All header files for this module List of C++ source files

Determine whether optimization should be enabled for a given target

The optimization setting from the rules file The active target configuration Whether the current module is an engine module Whether the current module should be compiled with code coverage support True if optimization should be enabled

Creates a compile environment from a base environment based on the module settings.

Rules for the target being built An existing environment to base the module compile environment on. Logger for output The new module compile environment.

Creates a compile environment for a shared PCH from a base environment based on the module settings.

The target being built An existing environment to base the module compile environment on. The new shared PCH compile environment.

Finds all the source files that should be built for this module

The platform the module is being built for Map of directory to source files inside it Logger for output Set of source files that should be built

Finds all the source files that should be built for this module

Directory to search from Set of excluded directory names (eg. other platforms) Set of all non-empty source directories. Map from directory to source files inside it Collection of source files, categorized by type Logger for output

Finds the input files that should be built for this module, from a given directory

Logger for output Array of source files

Gets a set of source files for the given directory. Used to detect when the makefile is out of date.

Logger for output Array of source files

Gets a set of source files and headers for the given directory. Used to detect when the makefile is out of date due to a new directory

Logger for output Array of source files and headers

Checks a given directory path whether it exists and if it contains any Verse source files

A module that is never compiled by us, and is only used to group include paths and libraries into a dependency unit.

Enum for the different ways a platform can support multiple architectures within UnrealBuildTool

This platform only supports a single architecture (consoles, etc)

This platform needs separate targets per architecture (compiling for multiple will compile two entirely separate set of source/exectuable/intermediates)

This will create a single target, but compile each source file separately

This will create a single target, but compile each source file and link the executable separately - but then packaged together into one final output

Full architecture configuation information for a platform. Can be found by platform with UnrealArchitectureConfig.ForPlatform(), or UEBuildPlatform.ArchitectureConfig

Get the architecture configuration object for a given platform

Get all known ArchitectureConfig objects

The multi-architecture mode for this platform (potentially single-architecture)

The set of all architecture this platform supports. Any platform specified on the UBT commandline not in this list will be an error

This determines what architecture(s) to compile/package when no architeecture is specified on the commandline

Like ProjectSupportedArchitectures, except when building in distribution mode. Defaults to ActiveArchitectures

Returns the set all architectures potentially supported by this project. Can be used by project file gnenerators to restrict IDE architecture options Defaults to AllSupportedArchitectures

Returns if architecture name should be used when making intermediate directories, per-architecture filenames, etc It is virtual, so a platform can choose to skip architecture name for one platform, but not another

Convert user specified architecture strings to what the platform wants

Get name for architecture-specific directories (can be shorter than architecture name itself)

Get name for architecture-specific directories (can be shorter than architecture name itself)

Returns the architecture of the currently running OS (only used for desktop platforms, so will throw an exception in the general case)

Simple constructor for platforms with a single architecture

Full constructor for platforms that support multiple architectures

The corresponding target platform enum

The configuration about the architecture(s) this platform supports

Logger for this platform

All the platform folder names

Cached copy of the list of folders to include for this platform

Cached copy of the list of folders to exclude for this platform

Constructor.

The enum value for this platform The SDK management object for this platform THe architecture configuraton for this platform. This is returned by UnrealArchitectureConfig.ForPlatform() Logger for output

Finds all the UEBuildPlatformFactory types in this assembly and uses them to register all the available platforms, and uses a UBT commandline to check for per-project SDKs

Whether to register platforms that are not installed Only register the host platform Commandline args to look through for finding uprojects, to look up per-project SDK versions The UBT mode (usually Build, but Logger for output

Finds all the UEBuildPlatformFactory types in this assembly and uses them to register all the available platforms, and uses a UAT commandline to check for per-project SDKs

Whether to register platforms that are not installed Only register the host platform Commandline args to look through for finding uprojects, to look up per-project SDK versions Logger for output

Gets an array of all platform folder names

Array of platform folders

Finds a list of folder names to include when building for this platform

Finds a list of folder names to exclude when building for this platform

Whether the required external SDKs are installed for this platform. Could be either a manual install or an AutoSDK.

Whether this platform requires specific Visual Studio version.

The version required to support Visual Studio

Gets all the registered platforms

Sequence of registered platforms

Searches a directory tree for build products to be cleaned.

The directory to search Target or application names that may appear at the start of the build product name (eg. "UnrealEditor", "ShooterGameEditor") Suffixes which may appear at the end of the build product name List to receive a list of files to be cleaned List to receive a list of directories to be cleaned

Enumerates any additional directories needed to clean this target

The target to clean Receives a list of files to be removed Receives a list of directories to be removed

Determines if a filename is a default UBT build product

The name to check Target or application names that may appear at the start of the build product name (eg. "UnrealEditor", "ShooterGameEditor") Suffixes which may appear at the end of the build product name True if the substring matches the name of a build product, false otherwise

Determines if the given name is a build product for a target.

The name to check Target or application names that may appear at the start of the build product name (eg. "UnrealEditor", "ShooterGameEditor") Suffixes which may appear at the end of the build product name True if the string matches the name of a build product, false otherwise

Determines if a string is in the canonical name of a UE build product, with a specific extension (eg. "UnrealEditor-Win64-Debug.exe" or "UnrealEditor-ModuleName-Win64-Debug.dll").

The file name to check Target or application names that may appear at the start of the build product name (eg. "UnrealEditor", "ShooterGameEditor") Suffixes which may appear at the end of the build product name The extension to check for True if the string matches the name of a build product, false otherwise

Determines if a substring is in the canonical name of a UE build product, with a specific extension (eg. "UnrealEditor-Win64-Debug.exe" or "UnrealEditor-ModuleName-Win64-Debug.dll").

The name to check Index of the first character to be checked Number of characters of the substring to check Target or application names that may appear at the start of the build product name (eg. "UnrealEditor", "ShooterGameEditor") Suffixes which may appear at the end of the build product name The extension to check for True if the substring matches the name of a build product, false otherwise

Determines if a substring is in the canonical name of a UE build product, excluding extension or other decoration (eg. "UnrealEditor-Win64-Debug" or "UnrealEditor-ModuleName-Win64-Debug").

The name to check Index of the first character to be checked Number of characters of the substring to check Target or application names that may appear at the start of the build product name (eg. "UnrealEditor", "ShooterGameEditor") Suffixes which may appear at the end of the build product name True if the substring matches the name of a build product, false otherwise

Get the bundle directory for the shared link environment

The target rules List of executable output files Path to the bundle directory

Determines whether a given platform is available

The platform to check for Ignore the sdks presence when checking for platform availablity (many platforms can be cooked as a target platform without requiring sdk) True if it's available, false otherwise

Determines whether a given platform is available in the context of a particular Taget

The platform to check for A Target object that may further restrict available platforms Ignore the sdks presence when checking for platform availablity (many platforms can be cooked as a target platform without requiring sdk) True if it's available, false otherwise

Register the given platforms UEBuildPlatform instance

The UEBuildPlatform instance to use for the InPlatform Logger for output

Assign a platform as a member of the given group

Retrieve the list of platforms in this group (if any)

Enumerates all the platform groups for a given platform

The platform to look for List of platform groups that this platform is a member of

Retrieve the IUEBuildPlatform instance for the given TargetPlatform

The UnrealTargetPlatform being built UEBuildPlatform The instance of the build platform

Retrieve the IUEBuildPlatform instance for the given TargetPlatform

The UnrealTargetPlatform being built UEBuildPlatform The instance of the build platform

Allow all registered build platforms to modify the newly created module passed in for the given platform. This is not required - but allows for hiding details of a particular platform.

The name of the module The module rules The target being build

Returns the delimiter used to separate paths in the PATH environment variable for the platform we are executing on.

Gets the platform name that should be used.

If this platform can be compiled with XGE

If this platform can be compiled with FASTBuild

If this platform can be compiled with SN-DBS

Set all the platform-specific defaults for a new target

Validate a target's settings

Validate a plugin's settings

Validate a UEBuildModule before it's processed The UEBuildModule that needs to be validated Options for the target being built

Validate a UEBuildModule's include paths before it's processed

The UEBuildModule that needs to be validated Options for the target being built Other modules to validate against, if needed

Return whether the given platform requires a monolithic build

The platform of interest The configuration of interest

Get the extension to use for the given binary type

The binary type being built string The binary extension (i.e. 'exe' or 'dll')

Get the extensions to use for debug info for the given binary type

Options for the target being built The binary type being built string[] The debug info extensions (i.e. 'pdb')

Whether this platform should build a monolithic binary

Modify the rules for a newly created module, where the target is a different host platform. This is not required - but allows for hiding details of a particular platform.

The name of the module The module rules The target being build

For platforms that need to output multiple files per binary (ie Android "fat" binaries) this will emit multiple paths. By default, it simply makes an array from the input

Return all valid configurations for this platform Typically, this is always Debug, Development, and Shipping - but Test is a likely future addition for some platforms

Check for the default configuration return true if the project uses the default build config

Check for whether we require a build for platform reasons return true if the project requires a build

Get a list of extra modules the platform requires. This is to allow undisclosed platforms to add modules they need without exposing information about the platform.

The target being build List of extra modules the platform needs to add to the target

Modify the rules for a newly created module, in a target that's being built for this platform. This is not required - but allows for hiding details of a particular platform.

The name of the module The module rules The target being build

Setup the target environment for building

Settings for the target being compiled The compile environment for this target The link environment for this target

Setup the configuration environment for building

The target being built The global compile environment The global link environment

Allows the platform to return various build metadata that is not tracked by other means. If the returned string changes, the makefile will be invalidated.

The project file being built String describing the current build metadata

Allows the platform to return various build metadata that is not tracked by other means. If the returned string changes, the makefile will be invalidated.

The project file being built String builder to contain build metadata

Allows the platform to modify the binary link environment before the binary is built

The binary link environment being created The binary compile environment being used The target rules in use The toolchain being used Action graph that is used to build the binary

Indicates whether this platform requires a .loadorder file to be generated for the build. .loadorder files contain a list of dynamic modules and the exact order in which they should be loaded to ensure that all dependencies are satisfied i.e. we don't attempt to load a module without loading all its dependencies first. As such, this file is only needed in modular builds on some platforms (depending on the way they implement dynamic modules such as DLLs).

The target rules in use True if .loadorder file should be generated

Checks if platform is part of a given platform group

The platform to check The platform group to check True if platform is part of a platform group

Gets the SDK object that was passed in to the constructor

The SDK object

Gets the SDK object that was passed in to the constructor to the UEBuildPlatform constructor for this platform

The SDK object

Whether this platform should create debug information or not

The target being built bool true if debug info should be generated, false if not

Creates a toolchain instance for this platform. There should be a single toolchain instance per-target, as their may be state data and configuration cached between calls.

The target being built New toolchain instance.

Deploys the given target

Receipt for the target being deployed

Factory class for registering platforms at startup

Gets the target platform for an individual factory

Register the platform with the UEBuildPlatform class

Stores information about a plugin that is being built for a target

Information about the plugin

Modules that this plugin belongs to

Recursive

Whether the descriptor for this plugin is needed at runtime; because it has modules or content which is used, or because it references another module that does.

Whether this descriptor is referenced non-optionally by something else; a project file or other plugin. This is recursively applied to the plugin's references.

Chain of references to this plugin

Constructor

The static plugin information Chain of references to this plugin

Accessor for the name of this plugin

Accessor for the file for this plugin

Accessor for the child files for this plugin

Accessor for the type of the plugin

Accessor for this plugin's root directory

Accessor for this plugin's descriptor

Returns the name of this plugin for debugging

Name of the plugin

Public entry point to validate a module

true if there are any fatal errors

The platform we're building for

Return the single instance of the Group with this name

Return the single instance of the Group with this name

///

Return the string representation

Helper that just calls UEBuildPlatform.IsPlatformInGroup

Helper that just calls UEBuildPlatform.IsPlatformInGroup

64-bit Windows

Mac

iOS

Android

Linux

LinuxArm64

TVOS

VisionOS

Playstation 4

Playstation 5

Nintendo Switch

Adds WinGDK as a target platform identifier

Adds XB1 as a target platform identifier

legacy XboxOneGDK platform - for stale build graph parsing only

Adds XSX as a target platform identifier

Extension methods used for serializing UnrealTargetPlatform instances

Read an UnrealTargetPlatform instance from a binary archive

Archive to read from New UnrealTargetPlatform instance

Write an UnrealTargetPlatform instance to a binary archive

The archive to write to The platform to write

Platform groups

Return the single instance of the Group with this name

Return the string representation

this group is just to lump Win32 and Win64 into Windows directories, removing the special Windows logic in MakeListOfUnsupportedPlatforms

Microsoft platforms

Apple platforms

making IOS a group allows TVOS to compile IOS code

Unix platforms

Linux platforms

Android platforms

Desktop group - used by UnrealPlatformClass.Desktop

SDLPlatform is for platforms that use SDL for windows, cursors, etc

30Hz is for platforms that typically run at 30Hz (Android, Switch) vs. the baseline 60Hz

POSIX-compliant platforms

Add GDK to the known platform groups

Nintendo group

Sony platforms

XboxCommon group

The architecture we're building for

Return the single instance of the Group with this name

True if X64, false if not, or null if it's Default and will ask the platform later

Returns true if the architecure is X64 based

Return the string representation

64-bit x86/intel

64-bit arm

Used in place when needing to handle deprecated architectures that a licensee may still have. Do not use in normal logic

Maps to the currently running architecture on the host platform (lazy because this needs other classes to be intialized)

IOS Simulator

TVOS Simulator

Apple-specific low level name for the generic platforms

Returns the low-architecture specific string for the generic architectures

Version of Arm64 that can interop with X64 (Emulation Compatible)

Windows-specific tool chain to compile with

Windows-specific lib directory for this architecture

Windows-specific system lib directory for this architecture

Windows-specific low level name for the generic platforms

A collection of one or more architecetures

Construct a UnrealArchitectures object from a list of Architectures

Construct a UnrealArchitectures object from a list of string Architectures

Construct a UnrealArchitectures object from a single Architecture

Construct a UnrealArchitectures object from a single string Architecture

Construct a UnrealArchitectures object from another one

Creates an UnrealArchitectures from a string (created via ToString() or similar)

The list of architecture names in this set, sorted by architecture name

Gets the Architecture in the normal case where there is a single Architecture in Architectures, or throw an Exception if not single

True if there is is more than one architecture specified

Gets the Architectures list as a + delimited string

Convenience function to check if the given architecture is in this set

The class of platform. See Utils.GetPlatformsInClass().

All platforms

All desktop platforms (Win32, Win64, Mac, Linux)

All platforms which support the editor (Win64, Mac, Linux)

Platforms which support running servers (Win32, Win64, Mac, Linux)

The type of configuration a target can be built for. Roughly order by optimization level.

Unknown

Debug configuration

DebugGame configuration; equivalent to development, but with optimization disabled for game modules

Development configuration

Test configuration

Shipping configuration

Intermediate environment. Determines if the intermediates end up in a different folder than normal.

Default environment

Generate clang database environment is non unity and needs it own environment

Include what you use

Nonunity

Static code analysis

Query

Generate project files

Extension methods for UnrealIntermediateEnvironment enum

Returns if this environment should default to a unity build

The environment to check true if shold build unity by default

A container for a binary files (dll, exe) with its associated debug info.

A target that can be built

Creates a target object for the specified target name.

Information about the target Build configuration Logger for output

Creates a target object for the specified target name.

Information about the target Logger for output

Creates a target object for the specified target name.

Information about the target Logger for output

Creates a target object for the specified target name.

Information about the target Whether to skip compiling any rules assemblies Whether to always compile all rules assemblies Whether to use a precompiled engine build Intermediate environment to use Logger for output The build target object for the specified build rules source file

Validates that the build environment matches the shared build environment, by comparing the TargetRules instance to the vanilla target rules for the current target type.

Validate all plugins

true if there are any fatal errors

Validates a plugin

true if there are any fatal errors

Validates all plugins

true if there are any fatal errors

Validates a module

true if there are any fatal errors

The target rules

The rules assembly to use when searching for modules

Cache of source file metadata for this target

The project file for this target

The project descriptor for this target

Type of target

The name of the application the target is part of. For targets with bUseSharedBuildEnvironment = true, this is typically the name of the base application, eg. UnrealEditor for any game editor.

The name of the target

Whether the target uses the shared build environment. If false, AppName==TargetName and all binaries should be written to the project directory.

Platform as defined by the VCProject and passed via the command line. Not the same as internal config names.

Target as defined by the VCProject and passed via the command line. Not necessarily the same as internal name.

The architecture this target is being built for

Intermediate environment. Determines if the intermediates end up in a different folder than normal.

Relative path for platform-specific intermediates (eg. Intermediate/Build/Win64/x64)

Relative path for platform-specific intermediates that explicitly do not need an architeecture (eg. Intermediate/Build/Win64)

Root directory for the active project. Typically contains the .uproject file, or the engine root.

Default directory for intermediate files. Typically underneath ProjectDirectory.

Default directory for intermediate files. Typically underneath ProjectDirectory.

Directory for engine intermediates. For an agnostic editor/game executable, this will be under the engine directory. For monolithic executables this will be the same as the project intermediate directory.

All plugins which are built for this target

All plugin dependencies for this target. This differs from the list of plugins that is built for Launcher, where we build everything, but link in only the enabled plugins.

Specifies the path to a specific plugin to compile.

When building a foreign plugin, whether to build plugins it depends on as well.

Collection of all UBT plugins (project files)

Collection of all enabled UBT plugins (project files)

Collection of all enabled UHT plugin assemblies

All application binaries; may include binaries not built by this target.

Kept to determine the correct module parsing order when filtering modules.

true if target should be compiled in monolithic mode, false if not

Used to keep track of all modules by name.

Filename for the receipt for this target.

The name of the .Target.cs file, if the target was created with one

Whether to deploy this target after compilation

Whether this target should be compiled in monolithic mode

true if it should, false if it shouldn't

Whether this target was compiled with an overridden sdk (usually from a platform .ini specifying an alternate SDK version)

Constructor.

Target descriptor The target rules, as created by RulesCompiler. The chain of rules assemblies that this target was created with Logger for output

Gets the intermediate directory for a given platform

Platform to get the folder for Architectures to get the folder for Insert External after Intermediate - for out-of-tree plugins The output directory for intermediates

Adjusts a target name to be a usable intermediate folder name.

Base target name Intermediate environment to use

Gets the app name for a given target type

The target type The app name for this target type

Writes a list of all the externally referenced files required to use the precompiled data for this target

Path to the dependency list List of all the runtime dependencies for this target Map of runtime dependencies to their location in the source tree, before they are staged Logger for output

Generates a public manifest file for writing out

Prepare all the module manifests for this target

Dictionary mapping from filename to module manifest

Prepare all the receipts this target (all the .target and .modules files). See the VersionManifest class for an explanation of what these files are.

The toolchain used to build the target Artifacts from the build Output runtime dependencies

Gathers dependency modules for given binaries list.

Binaries list. Dependency modules set.

Creates a global compile environment suitable for generating project files.

New compile environment

Builds the target, appending list of output files and returns building result.

Gets the output directory for the main executable

The executable directory

Check that copying a file from one location to another does not violate rules regarding restricted folders

The destination location for the file The source location of the file Logger for output True if the copy is permitted, false otherwise

Gets the restricted folders that the given file is in

The file to test List of restricted folders for the file

Creates a toolchain for the current target. May be overridden by the target rules.

New toolchain instance

Cleans any stale modules that have changed moved output folder. On Windows, the loader reads imported DLLs from the first location it finds them. If modules are moved from one place to another, we have to be sure to clean up the old versions so that they're not loaded accidentally causing unintuitive import errors.

Check whether a reference from an engine module to a plugin module is allowed. 'Temporary' hack until these can be fixed up properly.

Name of the engine module. Name of the plugin module. True if the reference is allowed.

Export the definition of this target to a JSON file

File to write to List of actions to export

Writes a header for the given binary that allows including headers from it in an external application

Binary to write a header for Path to the header to output The global compile environment for this target

Check for EULA violation dependency issues.

Tells if this module can be redistributed.

Dynamically merge modules into libraries based on target settings

Setup target before build. This method finds dependencies, sets up global environment etc.

Creates scripts for executing the pre-build scripts

Creates scripts for executing post-build steps

Array of post-build scripts

Adds custom build steps from the given JSON object to the list of command batches

The custom build steps The plugin to associate with these commands List to receive the command batches

Gets a list of variables that can be expanded in paths referenced by this target

The current plugin Map of variable names to values

Write scripts containing the custom build steps for the given host platform

The current host platform The output directory for the scripts Bare prefix for all the created script files List of custom build steps, and their matching PluginInfo (if appropriate) List of created script files

Finds a list of module names which can be hot-reloaded

Set of module names

Determines which modules can be used to create shared PCHs

The list of binaries The compile environment. The shared PCHs will be added to the SharedPCHs list in this. Logger for output

Creates all the shared PCH instances before processing the modules

The target being built The toolchain to build with The list of binaries The compile environment. The shared PCHs will be added to the SharedPCHs list in this. Logger for output List of build actions

When building a target, this is called to add any additional modules that should be compiled along with the main target. If you override this in a derived class, remember to call the base implementation!

Adds all the precompiled modules into the target. Precompiled modules are compiled alongside the target, but not linked into it unless directly referenced.

Gets the output directory for a target

The base directory for output files Path to the target file The output directory for this target

Finds the base output directory for build products of the given module

The rules object created for this module The base output directory for compiled object files for this module

Finds the base output directory for a module

The rules object created for this module The architectures (or none) to insert into the directory structure The output directory for compiled object files for this module

Adds a dynamic library for the given module. Does not check whether a binary already exists, or whether a binary should be created for this build configuration.

The module to create a binary for The new binary. This has not been added to the target.

Adds a dynamic library for the given set of modules. Does not check whether a binary already exists, or whether a binary should be created for this build configuration.

The name of the merged binary The modules to create a binary for The new binary. This has not been added to the target.

Makes a filename (without path) for a compiled binary (e.g. "Core-Win64-Debug.lib") */

The name of this binary The separator for a decorated filename The platform being built for The configuration being built The target architectures being built The target configuration which doesn't require a platform and configuration suffix. Development by default. Type of binary Name of the binary

Determine the output path for a target's executable

The base directory for the executable; typically either the engine directory or project directory. Name of the binary Target platform to build for Target configuration being built Architectures being built The type of binary we're compiling The configuration which doesn't have a "-{Platform}-{Configuration}" suffix added to the binary Whether this executable contains game modules Subfolder for executables. May be null. The project file containing the target being built Rules for the target being built List of executable paths for this target

Sets up the uproject modules for this target

Sets up the plugins for this target

Modify a module rules based on the current target, be very careful not to violate the shared environment!

name of the module the module's rules

Creates a plugin instance from a reference to it

Reference to the plugin Textual representation of the chain of references, for error reporting Array of folder names to be excluded Map from plugin name to instance of it Map from plugin name to information Logger for diagnostic output Instance of the plugin, or null if it should not be used

Checks whether a plugin path contains a platform directory fragment

Scan for UBT plugins. This also detects if the current target has a C++ style UHT that don't have an associated UBT/UHT plugin. When this happens, the old UHT must be used.

Sets up the binaries for the target.

Sets up the global compile and link environment for the target.

Create a rules object for the given module, and set any default values for this target

Utility function to remove trailing slashes from a list of paths

List of paths to process

Determines the relative base directory path from the specified Binary directory to the Engine base directory if possible.

Directory that contains the platform subdirectoies for each UBT built binary Platform that the binary is for A string specifying the relative path from the binary directory to the engine base dir, or null if this isn't contained within the engine hierarhcy

Finds a module given its name. Throws an exception if the module couldn't be found.

Name of the module Chain of references causing this module to be instantiated, for display in error messages Logger for output

Constructs a new C++ module

Name of the module Chain of references causing this module to be instantiated, for display in error messages Logger for output New C++ module

Normalize an include path to be relative to the engine source directory

Finds a module given its name. Throws an exception if the module couldn't be found.

Combines a list of paths with a base path.

Base path to combine with. May be null or empty. List of input paths to combine with. May be null. List of paths relative The build module object for the specified build rules source file

This replaces the VCToolPath64 readonly property that was available in 4.19 . Note that GetVCToolPath64 is still used internally, but the property for it is no longer exposed.

This replaces the InstallDir readonly property that was available in 4.19.

Executor to use for local actions

Used to specify the location of fbuild.exe if the distributed binary isn't being used

Controls network build distribution

Used to specify the location of the brokerage. If null, FASTBuild will fall back to checking FASTBUILD_BROKERAGE_PATH

Used to specify the FASTBuild coordinator IP or network name. If null, FASTBuild will fall back to checking FASTBUILD_COORDINATOR

Controls whether to use caching at all. CachePath and FASTCacheMode are only relevant if this is enabled.

Cache access mode - only relevant if bEnableCaching is true;

Used to specify the location of the cache. If null, FASTBuild will fall back to checking FASTBUILD_CACHE_PATH

Whether to force remote

Whether to stop on error

Which MSVC CRT Redist version to use

Which MSVC Compiler version to use

Constructor

Results from a run action

Console log lines Process return code. Zero is assumed to be success and all other values an error. Wall time CPU time Additional description of action

Results from a run action

Console log lines Process return code. Zero is assumed to be success and all other values an error. Wall time CPU time Additional description of action

Console log lines

Process return code. Zero is assumed to be success and all other values an error.

Wall time

CPU time

Additional description of action

Defines the phase of execution

Check for already existing artifacts for the inputs

Compile the action

Defines the type of the runner.

Will be used to queue jobs as part of general requests

Will only be used for manual requests to queue jobs

Actions are assigned a runner when they need executing

Type of the runner The action phase that this step supports Function to be run queue running a task If true, use the action weight as a secondary limit Maximum number of action actions Maximum weight of actions

Actions are assigned a runner when they need executing

Type of the runner The action phase that this step supports Function to be run queue running a task If true, use the action weight as a secondary limit Maximum number of action actions Maximum weight of actions

Type of the runner

The action phase that this step supports

Function to be run queue running a task

If true, use the action weight as a secondary limit

Maximum number of action actions

Maximum weight of actions

Current number of active actions

Current weight of actions

Used to track if the runner has already scanned the action list for a given change count but found nothing to run.

True if the current limits have not been reached.

Helper class to manage the action queue Running the queue can be done with a mixture of automatic and manual runners. Runners are responsible for performing the work associated with an action. Automatic runners will have actions automatically queued to them up to the point that any runtime limits aren't exceeded (such as maximum number of concurrent processes). Manual runners must have jobs queued to them by calling TryStartOneAction or StartManyActions with the runner specified. For example: ParallelExecutor uses an automatic runner exclusively. UBAExecutor uses an automatic runner to run jobs locally and a manual runner to run jobs remotely as processes become available.

Number of second of no completed actions to trigger an action stall report. If zero, stall reports will not be enabled.

Number of second of no completed actions to trigger to terminate the queue. If zero, force termination not be enabled.

Running status of the action

Queued waiting for execution

Action is running

Action has successfully finished

Action has finished with an error

Used to track the state of each action

Action to be executed

Phase of the action

Current status of the execution

Runner assigned to the action

Optional execution results

Indices to prereq actions

State information about each action

Output logging

Total number of actions

Process group

Source for the cancellation token

Cancellation token

Progress writer

Overall success of the action queue

Whether to show compilation times along with worst offenders or not.

Whether to show CPU utilization after the work is complete.

Add target names for each action executed

Whether to log command lines for actions being executed

Whether to show compilation times for each executed action

Collapse non-error output lines

When enabled, will stop compiling targets after a compile error occurs.

Return true if the queue is done

Action that can be to notify when artifacts have been read for an action

Action that can be to notify when artifacts have been missed

Collection of available runners

First action to start scanning for actions to run

Action to invoke when writing tool output

Flush the tool output after logging has completed

Timer used to collect CPU utilization

Per-second logging of cpu utilization

Collection of all actions remaining to be logged

Task waiting to process logging

Used only by the logger to track the [x,total] output

Tracks the number of completed actions.

Tracks the number of completed actions from cache hits.

Tracks the number of unsuccessful actions from cache misses.

Flags used to track how StartManyActions should run

Number of changes to the action list

If true, an action stall has been reported for the current change count

If true, the queue has been cancelled due to an action stall

Time of the last change to the action count. This is updated by the timer.

Copy of _lastActionChange used to detect updates by the time.

Used to terminate the run with status

The last action group printed in multi-target builds

If set, artifact cache used to retrieve previously compiled results and save new results

Construct a new instance of the action queue

Collection of actions If true, the artifact cache is being used Max number of concurrent artifact cache tasks Text to be displayed with the progress writer Action to invoke when writing tool output Action to invoke when flushing tool output Logging interface

Event handler for the Console.CancelKeyPress event

Create a new automatic runner

Action to be run queue running a task If true, use the action weight as a secondary limit Maximum number of action actions Maximum weight of actions Created runner

Create a manual runner

Action to be run queue running a task If true, use the action weight as a secondary limit Maximum number of action actions Maximum weight of actions Created runner

Start the process of running all the actions

Run the actions until complete

True if completed successfully

Get the number of actions that were run, and how many succeeded or failed

Out parameter, the total number of actions Out parameter, the number of successful actions Out parameter, the number of failed actions Out parameter, the number of cache hit actions Out parameter, the number of cache miss actions

Return an enumeration of ready compile tasks. This is not executed under a lock and does not modify the state of any actions.

Enumerations of all ready to compile actions.

Try to start one action

If specified, tasks will only be queued to this runner. Otherwise all manual runners will be used. True if an action was run, false if not

Handle an exception running a task

Action that has been run Thrown exception

Try to start one action.

If specified, tasks will only be queued to this runner. Otherwise all manual runners will be used. Action to be run if something was queued and the number of completed actions

Start as many actions as possible.

If specified, all actions will be limited to the runner

Dispose the object

Reset the status of the given action to the queued state.

Action being re-queued

Notify the system that an action has been completed.

Action being completed If true, the action succeeded or false if it failed. Optional execution results

Set the new state of an action. Can only set state to Queued, Finished, or Error

Action being set Status to set Optional results

Add the number of completed actions and signal done if all actions complete.

Number of completed actions to add. If int.MaxValue, then the number is immediately set to total actions

Returns the number of queued actions left (including queued actions that will do artifact check first) Note, this method is lockless and will not always return accurate count

Optional function to filter out actions. Return false if action should not be included

Purge the pending logging actions

Log an action that has completed

Action that has completed Results of the action

Generate the final summary display

Get the ready state of an action

Action in question Action ready state

This executor uses async Tasks to process the action graph

Maximum processor count for local execution.

Processor count multiplier for local execution. Can be below 1 to reserve CPU for other tasks. When using the local executor (not XGE), run a single action on each CPU core. Note that you can set this to a larger value to get slightly faster build times in many cases, but your computer's responsiveness during compiling may be much worse. This value is ignored if the CPU does not support hyper-threading.

Free memory per action in bytes, used to limit the number of parallel actions if the machine is memory starved. Set to 0 to disable free memory checking.

The priority to set for spawned processes. Valid Settings: Idle, BelowNormal, Normal, AboveNormal, High Default: BelowNormal or Normal for an Asymmetrical processor as BelowNormal can cause scheduling issues.

When enabled, will stop compiling targets after a compile error occurs.

Whether to show compilation times along with worst offenders or not.

Whether to show compilation times for each executed action

Whether to log command lines for actions being executed

Add target names for each action executed

Whether to take into account the Action's weight when determining to do more work or not.

Whether to show CPU utilization after the work is complete.

Collapse non-error output lines

How many processes that will be executed in parallel

Constructor

How many actions to execute in parallel Consider logical cores when determining how many total cpu cores are available Should output be written in a compact fashion Logger for output

Returns the name of this executor

Checks whether the task executor can be used

True if the task executor can be used

Telemetry event for this executor

Create an action queue

Actions to be executed Artifact cache Max artifact tasks that can execute in parallel Logging interface Action queue

Publicly visible static class that allows external access to the parallel executor config

Maximum number of processes that should be used for execution

Maximum number of processes that should be used for execution

When enabled, SN-DBS will stop compiling targets after a compile error occurs. Recommended, as it saves computing resources for others.

When set to false, SNDBS will not be enabled when running connected to the coordinator over VPN. Configure VPN-assigned subnets via the VpnSubnets parameter.

List of subnets containing IP addresses assigned by VPN

Executes the process, parsing progress markup as part of the output.

SN-DBS templates that are automatically included in the build.

ID for this Horde session

Executes the provided actions

True if all the tasks successfully executed, or false if any of them failed.

Determine if an action must be run locally and with no detouring

The action to check If this action must be local, non-detoured

Determine if an action is able to be run remotely

The action to check If this action can be run remotely

UBAExecutor, but force local only compiles regardless of other settings

Configuration for Unreal Build Accelerator

When set to true, UBA will not use any remote help

When set to true, UBA will force all actions that can be built remotely to be built remotely. This will hang if there are no remote agents available

When set to true, actions that fail locally with UBA will be retried without UBA.

When set to true, actions that fail remotely with UBA will be retried locally with UBA.

When set to true, all errors and warnings from UBA will be output at the appropriate severity level to the log (rather than being output as 'information' and attempting to continue regardless).

If UBA should store cas compressed or raw

If UBA should distribute linking to remote workers. This needs bandwidth but can be an optimization

The amount of gigabytes UBA is allowed to use to store workset and cached data. It is a good idea to have this >10gb

Max number of worker threads that can handle messages from remotes.

Max size of each message sent from server to client

Which ip UBA server should listen to for connections

Which port UBA server should listen to for connections.

Which directory to store files for UBA.

Use Quic protocol instead of Tcp (experimental)

Enable logging of UBA processes

Prints summary of UBA stats at end of build

Launch visualizer application which shows build progress

Resets the cas cache

Provide custom path for trace output file

Add verbose details to the UBA trace

Disable UBA waiting on available memory before spawning new processes

Let UBA kill running processes when close to out of memory

Store object (.obj) compressed on disk. Requires uba to do link step where it will decompress obj files again

Threshold for when executor should output logging for the process. Defaults to never

Skip writing intermediate and output files to disk. Useful for validation builds where we don't need the output

Set to true to disable mimalloc and detouring of memory allocations.

The zone to use for UBA.

Set to true to enable encryption when transferring files over the network.

Set to true to provide known inputs to processes that are run remote. This is an experimental feature to speed up build times when ping is higher

Write yaml file with all actions that are queued for build. This can be used to replay using "UbaCli.exe local file.yaml"

Set to true to see more info about what is happening inside uba and also log output from agents

Address of the uba cache service. Will automatically use cache if connected

Set cache to write instead of fetch

Max number of cache download tasks that can execute in parallel

Report reason a cache miss happened. Useful when searching for determinism/portability issues

Configuration for Unreal Build Accelerator Horde session

Uri of the Horde server

Auth token for the Horde server

OIDC id for the login to use

Pool for the Horde agent to assign, calculated based on platform and overrides

Pool for the Horde agent to assign if no override current platform doesn't have it set

Pool for the Horde agent to assign, only used for commandline override

Pool for the Horde agent to assign when on Linux

Pool for the Horde agent to assign when on Mac

Pool for the Horde agent to assign when on Windows

Requirements for the Horde agent to assign

Default compute cluster ID if nothing is set

Compute cluster ID for automatically resolving the most suitable cluster

Compute cluster ID to use in Horde. Set to "_auto" to let Horde server resolve a suitable cluster. In multi-region setups this is can simplify configuration of UBT/UBA a lot.

Which ip UBA server should give to agents. This will invert so host listens and agents connect

Max cores allowed to be used by build session

How long UBT should wait to ask for help. Useful in build configs where machine can delay remote work and still get same wall time results (pch dependencies etc)

Allow use of Wine. Only applicable to Horde agents running Linux. Can still be ignored if Wine executable is not set on agent.

Connection mode for agent/compute communication for valid modes.

Encryption to use for agent/compute communication. Note that UBA agent uses its own encryption. for valid modes.

Sentry URL to send box data to. Optional.

Disable horde all together

Enabled parameter for use by INI config, expects one of [True, False, BuildMachineOnly]

Whether to use the no_watchdog_thread option to prevent VS2015 toolchain stalls.

Whether to display the XGE build monitor.

When enabled, XGE will stop compiling targets after a compile error occurs. Recommended, as it saves computing resources for others.

When set to false, XGE will not be enabled when running connected to the coordinator over VPN. Configure VPN-assigned subnets via the VpnSubnets parameter.

List of subnets containing IP addresses assigned by VPN

Whether to allow remote linking

Whether to enable the VCCompiler=true setting. This requires an additional license for VC tools.

Minimum number of actions to use XGE execution.

Check for a concurrent XGE build and treat the XGE executor as unavailable if it's in use. This will allow UBT to fall back to another executor such as the parallel executor.

Writes a XGE task file containing the specified actions to the specified file path.

The possible result of executing tasks with XGE.

Executes the tasks in the specified file.

- The path to the file containing the tasks to execute in XGE XML format. Indicates whether the tasks were successfully executed.

Executes the tasks in the specified file, parsing progress markup as part of the output.

Matches compile errors and annotates with the source file path and revision

Matcher for linker errors

Matcher for generic Microsoft errors (see https://docs.microsoft.com/en-us/cpp/build/formatting-the-output-of-a-custom-build-step-or-build-event?view=msvc-160)

Aggregates clang timing information files together into one monolithic breakdown file.

Aggregates parsed Visual C++ timing information files together into one monolithic breakdown file.

Outputs information about the given target, including a module dependecy graph (in .gefx format and list of module references)

Execute the command

Command line arguments Exit code

Identifies plugins with python requirements and attempts to install all dependencies using pip.

Full path to python interpreter engine was built with (if unspecified use value in PythonSDKRoot.txt)

The action the pip install tool should implement (GenRequirements, Setup, Parse, Install, ViewLicenses, default: Install)

Disable requiring hashes in pip install requirements (NOTE: this is insecure and may simplify supply-chain attacks)

Allow overriding the index url (this will also disable extra-urls)

Run pip installer on all plugins in project and engine

Execute the command

Command line arguments Exit code

PipEnv helper class for setting up a self-contained pip environment and running pip commands (particularly pip install) within that env.

Simple interface for logging command stdout/stderr with progress tags if supported

Simple factory types so that users don't need to implement the factory

Basic command logger which just echos output/errors to Logger (indent stdout data by 2 spaces)

Pyuthon command wraps python logging facility outputs to appropriate log channel

Basic command writer that redirects stdout to file, and writes stderr normally (used to output pip freeze to file)

Simple interface for logging command stdout/stderr with progress tags if supported

Implement the UHT configuration interface. Due to the configuration system being fairly embedded into UBT, the implementation must be part of UBT.

Types that have been renamed, treat the old deprecated name as the new name for code generation

Meta data that have been renamed, treat the old deprecated name as the new name for code generation

Supported units in the game

Special parsed struct names that do not require a prefix

Special parsed struct names that have a 'T' prefix

Mapping from 'human-readable' macro substring to # of parameters for delegate declarations Index 0 is 1 parameter, Index 1 is 2, etc...

Default version of generated code. Defaults to oldest possible, unless specified otherwise in config.

Internal version of pointer warning for native pointers in the engine

Internal version of pointer warning for object pointers in the engine

Internal version of pointer warning for native pointers in engine plugins

Internal version of pointer warning for object pointers in engine plugins

Internal version of pointer warning for native pointers outside the engine

Internal version of pointer warning for object pointers outside the engine

If true, deprecation warnings should be shown

If true, UObject properties are enabled in RigVM

If true, UInterface properties are enabled in RigVM

Internal version of behavior when there is a missing generated header include in the engine code.

Internal version of behavior when there is a missing generated header include in non engine code.

Internal version of the behavior set when the underlying type of a regular and namespaced enum isn't set in the engine code.

Internal version of the behavior set when the underlying type of a regular and namespaced enum isn't set in the non engine code.

Collection of known documentation policies

Default documentation policy (usually empty)

If true, UObject properties are enabled in RigVM

If true, UInterface properties are enabled in RigVM

If true, deprecation warnings should be shown

Read the UHT configuration

Extra command line arguments

Global options for UBT (any modes)

User asked for help

The amount of detail to write to the log

Specifies the path to a log file to write. Note that the default mode (eg. building, generating project files) will create a log file by default if this not specified.

Whether to include timestamps in the log

Whether to format messages in MsBuild format

Disables all logging including the default log location

Initialize the options with the given command line arguments

File manager for the test harness

Collection of test fragments that can be read

All output segments generated by code gen

Construct a new instance of the test file manager

Root directory of the UE

Add a source file fragment to the session. When requests are made to read sources, the fragment list will be searched first.

Source file The relative path to add Starting line number The data associated with the path

Testing harness to run the test scripts

Invoke UHT

Directory for saved application settings (typically Engine/Programs)

The engine programs directory

Print (incomplete) usage information

Defined exporters Configuration

Execute the command

Command line arguments Exit code

Options controlling how a target is built

Default options

Don't build anything, just do target setup and terminate

Just output a list of XGE actions; don't build anything

Fail if any engine files would be modified by the build

Builds a target

Specifies the file to use for logging.

Whether to skip checking for files identified by the junk manifest.

Skip building; just do setup and terminate.

Skip pre build targets; just do the main target.

Whether we should just export the XGE XML and pretend it succeeded

Do not allow any engine files to be output (used by compile on startup functionality)

Whether we should just export the outdated actions list

An optional directory to copy crash dump files into

If specified, then only this type of action will execute

Main entry point

Command-line arguments One of the values of ECompilationResult

Creates scripts for executing the init scripts (only supported on project descriptors)

The current target List of created script files

Write scripts containing the custom build steps for the given host platform

The current target The current host platform The output directory for the scripts Bare prefix for all the created script files List of custom build steps List of created script files

Gets a list of variables that can be expanded in paths referenced by this target

The current target Map of variable names to values

Build a list of targets

Target descriptors Current build configuration The source file working set Additional options for the build Files to write the list of outdated actions to (rather than building them) Logger for output If true then only the current target descriptors will be built. If specified, only actions of this type will be run Result from the compilation

Build a list of targets with a given set of makefiles.

Makefiles created with CreateMakefiles Target descriptors Current build configuration Additional options for the build Files to write the list of outdated actions to (rather than building them) Logger for output If specified, only actions of this type will be run Result from the compilation

If there are headers in the specific list, this function will exand the list to include all files that include those headers

List of files to compile Project file if there is one Actions to filter out expansion of files Logger for output

Outputs the toolchain used to build each target

List of targets being built Matching array of makefiles for each target Logger for output

Returns true if File is header

File to check

Creates the makefile for a target. If an existing, valid makefile already exists on disk, loads that instead.

The build configuration Target being built Set of source files which are part of the working set Logger for output Makefile for the given target

Determines all the actions that should be executed for a target (filtering for single module/file, etc..)

The target being built Makefile for the target Set of all output items List of actions that need to be executed

Merge action graphs for multiple targets into a single set of actions. Sets group names on merged actions to indicate which target they belong to.

List of target descriptors Array of actions for each target List of merged actions

Cleans build products and intermediates for the target. This deletes files which are named consistently with the target being built (e.g. UnrealEditor-Foo-Win64-Debug.dll) rather than an actual record of previous build products.

Whether to avoid cleaning targets

Skip pre build targets; just do the main target.

Main entry point

Command-line arguments One of the values of ECompilationResult

Invokes the deployment handler for a target.

If we are just running the deployment step, specifies the path to the given deployment settings

Execute the tool mode

Command line arguments Exit code

Builds a target

Whether we should just export the outdated actions list

Main entry point

Command-line arguments One of the values of ECompilationResult

Fixes the include paths found in a header and source file

Regex that matches #include statements.

Execute the command

Command line arguments Exit code

Generate a clang compile_commands file for a target

Optional set of source files to include in the compile database. If this is empty, all files will be included by default and -Exclude can be used to exclude some. Relative to the root directory, or to the project file.

Optional set of source files to exclude from the compile database. Relative to the root directory, or to the project file.

Execute any actions which result in code generation (eg. ISPC compilation)

Optionally override the output filename for handling multiple targets

Optionally overrite the output directory for the compile_commands file.

Execute the command

Command line arguments Exit code

Generates project files for one or more projects

Types of project files to generate

Disable native project file generators for platforms. Platforms with native project file generators typically require IDE extensions to be installed.

Whether this command is being run in an automated mode

Execute the tool mode

Command line arguments Exit code

Try to parse the project file from the command line

The command line arguments Logger for output The project file that was parsed True if the project file was parsed, false otherwise

Generate a clang compile_commands file for a target

Regex that matches #include statements.

Regex that matches #include generated header statements.

Regex that matches inline macro.

Execute the command

Command line arguments Exit code

Representing an #include inside a code file.

Full path using forward paths, eg: d:/dev/folder/file.h

Printable path for actual include. Does not include quotes or angle brackets. eg: folder/file.h

Reference to file info. Not populated with .iwyu file

Decides if printable should be #include quote or angle bracket

If true #include was found inside a declaration such as a namespace or class/struct/function

Comparer for include entries using printable to compare

Representing a forward declaration inside a code file. eg: class MyClass;

The string to add to the file

True if forward declaration has already been seen in the file

Representing an include that the code file needs that is missing in the include list Note, in cpp files it is listing the includes that are in the matching h file

Full path using forward paths, eg: d:/dev/folder/file.h

Representing a file (header or source). Each .iwyu file has a list of these (most of the time only one)

Full path of file using forward paths, eg: d:/dev/folder/file.h

Includes that this file needs. This is what iwyu have decided is used.

Forward declarations that this file needs. This is what iwyu have decided is used.

Includes seen in the file. This is how it looked like on disk.

Includes that didnt end up in the Includes list but is needed by the code file

Transitive includes. This is all the includes that someone gets for free when including this file Note, this is based on what iwyu believes should be in all includes. So it will not look at "seen includes" and only use its generated list.

Transitive forward declarations. Same as transitive includes

Which .iwyu file that produced this info. Note, it might be null for some special cases (like .generated.h files)

Module that this file belongs to

Is true if this file was included inside a declaration such as a namespace or class/struct/function

Is true if this file ends with .cpp

This is what include-what-you-use.exe produces for each build. a .iwyu file that is parsed into these instances

The different headers and source files that was covered by this execution of iwyu.

Name of .iwyu file

Profiles different unity sizes and prints out the different size and its timings

Specifies the file to use for logging.

Will check out files from p4 and write to disk

Update only includes in cpp files and don't touch headers

Which module to run IWYU on. Will also include all modules depending on this module

Which directory to run IWYU on. Will search for modules that has module directory matching this string If no module is found in -PathToUpdate it handles this for individual files instead. Note this can be combined with -ModuleToUpdate to double filter PathToUpdate supports multiple paths using semi colon separation

Same as PathToUpdate but provide the list of paths in a text file instead. Add all the desired paths on a separate line

Also update modules that are depending on the module we are updating

Will check out files from p4 and write to disk

Allow files to not add includes if they are transitively included by other includes

Will remove headers that are needed but redundant because they are included through other needed includes

Will skip compiling before updating. Handle with care, this is dangerous since files might not match .iwyu files

Will ignore update check that .iwyu is newer than source files.

If set, this will keep removed includes in #if/#endif scope at the end of updated file. Applied to non-private headers that are part of the Engine folder.

Compare current include structure with how it would look like if iwyu was applied on all files

For Development only - Will write a toc referencing all .iwyu files. Toc can be used by -ReadToc

For Development only - Will read a toc to find all .iwyu files instead of building the code.

Execute the command

Command line arguments Exit code

Calculate all indirect transitive includes for a file. This list contains does not contain itself and will handle circular dependencies

Exports a target as a JSON file

Execute any actions which result in code generation (eg. ISPC compilation)

Execute this command

Command line arguments Exit code (always zero)

Parses an MSVC timing info file generated from cl-filter to turn it into a form that can be used by other tooling. This is implemented as a separate mode to allow it to be done as part of the action graph.

Generate a clang compile_commands file for a target

Execute the command

Command line arguments Exit code

Profiles different unity sizes and prints out the different size and its timings

Set of filters for files to include in the database. Relative to the root directory, or to the project file.

Execute the command

Command line arguments Exit code

Compile the module multiple times looking for the best unity size

Print the timing data

Returns best compile timings after building the module times

Compiles the module and returns the timing information

Queries information about the targets supported by a project

Path to the project file to query

Path to the output file to receive information about the targets

Write out all targets, even if a default is specified in the BuildSettings section of the Default*.ini files.

Execute the mode

Command line arguments

Gets the path to the target info output file

Project file being queried Path to the output file

Writes information about the targets in an assembly to a file

The project file for the targets being built The rules assembly for this target Output file to write to Logger for output Include all targets even if a default target is specified for a given target type. Include all targets from parent assemblies (useful for EngineRules which can be chained)

Register all platforms (and in the process, configure all autosdks)

Execute the tool mode

Command line arguments Exit code

Builds low level tests on one or more targets.

Whether we're building implicit tests (default is explicit)

Whether we're cleaning tests instead of just building

Whether we're rebuilding tests instead of just building

Updates tests' build graph metadata files for explicit tests

Specific project file to run tests on or update test metadata

Main entry point

Command-line arguments

Validates the various platforms to determine if they are ready for building

Platforms to validate

Whether to validate all platforms

Whether to output SDK versions.

Executes the tool with the given arguments

Command line arguments Exit code

Generates documentation from reflection data

Enum for the type of documentation to generate

Type of documentation to generate

The HTML file to write to

Entry point for this command

Parameters for the WriteMetadata mode

The project file

Output location for the version file

The new version to write. This should only be set on the engine step.

Output location for the target file

The new receipt to write. This should only be set on the target step.

Map of module manifest filenames to their location on disk.

Map of load order manifest filenames to their locations on disk (generally, at most one load oder manifest is expected).

Constructor

Writes all metadata files at the end of a build (receipts, version files, etc...). This is implemented as a separate mode to allow it to be done as part of the action graph.

Version number for output files. This is not used directly, but can be appended to command-line invocations of the tool to ensure that actions to generate metadata are updated if the output format changes. The action graph is regenerated whenever UBT is rebuilt, so this should always match.

Execute the command

Command line arguments Exit code

Execute the command, having obtained the appropriate mutex

Command line arguments Logger for output Exit code

Checks if this

Attempts to read a manifest from the given location

Path to the manifest If successful, receives the manifest that was read True if the manifest was read correctly, false otherwise

Merge a manifest into another manifest

The source manifest The target manifest to merge into

Handler for AAR and JAR dependency determination and staging

Add a new respository path to search for AAR and JAR files

Directory containing the repository Logger for output

Add new respository paths to search for AAR and JAR files (recursive)

Root directory containing the repository Search pattern to match Logger for output

Adds a new required JAR file and resolves dependencies

Name of the package the JAR belongs to in repository Directory in repository containing the JAR Version of the AAR to use Logger instance

Adds a new required AAR file and resolves dependencies

Name of the package the AAR belongs to in repository Directory in repository containing the AAR Version of the AAR to use Logger for output Optionally process POM file for dependencies (default)

Copies the required JAR files to the provided directory

Destination path for JAR files Logger for output

Extracts the required AAR files to the provided directory

Destination path for AAR files Name of the package these AARs are being used with Logger for output

Extracts the contents of a zip file

Name of the zip file Output directory Logger for output List of files written

Interface to allow exposing public methods from the toolchain to other assemblies

Returns the Android NDK Level

The NDK Level

Returns the Current NDK Version

The NDK Version

Interface to allow exposing public methods from the Android deployment context to other assemblies

Public Android functions exposed to UAT

Logger for output

checks if the sdk is installed or has been synced

Base class for platform-specific project generators

Whether Android Game Development Extension is installed in the system. See https://developer.android.com/games/agde for more details. May be disabled by using -noagde on commandline

Enumerate all the platforms that this generator supports

Android-specific target settings

Enables address sanitizer (ASan)

Enables HW address sanitizer (HWASan)

Enables thread sanitizer (TSan)

Enables undefined behavior sanitizer (UBSan)

Enables minimal undefined behavior sanitizer (UBSan)

Enables runtime ray tracing support.

Enables the desktop renderer.

Enables ASIS plugin and STANDALONE support.

Read-only wrapper for Android-specific target settings

The private mutable settings object

Constructor

The settings object to wrap

Accessors for fields on the inner TargetRules instance

Modify the rules for a newly created module, where the target is a different host platform. This is not required - but allows for hiding details of a particular platform.

The name of the module The module rules The target being build

Modify the rules for a newly created module, in a target that's being built for this platform. This is not required - but allows for hiding details of a particular platform.

The name of the module The module rules The target being build

Internal usage for GetApiLevel

Determines whether we package data inside the APK. Based on and OR of "-ForcePackageData" being false and bPackageDataInsideApk in /Script/AndroidRuntimeSettings.AndroidRuntimeSettings being true

Ignore AppBundle (AAB) generation setting if "-ForceAPKGeneration" specified

Do not use Gradle if previous APK exists and only libUnreal.so changed

Whether UBT is invoked from MSBuild. If false will, disable bDontBundleLibrariesInAPK, unless forced .

Forcing bDontBundleLibrariesInAPK to "true" or "false" ignoring any other option.

Adds LD_PRELOAD'ed .so to capture all malloc/free/etc calls to libc.so and route them to our memory tracing.

Simple function to pipe output asynchronously

Reads the bPackageDataInsideApk from AndroidRuntimeSettings

Public Apple functions exposed to UAT

Is the current project using modern xcode?

Get the given project's Swift settings

This is a FilePath from UE settings, like /Game/Foo/Bar.txt

Directory to use for /Game paths

Convert UnrealTargetPlatform to the platform that Xcode uses for -destination

The architecture we are targeting (really, this is for Simulators)

Different ways that xcodebuild is run, so the scripts can behave appropriately

This is when hitting Build from in Xcode

This runs after building when building on commandline directly with UBT

This runs when making a fully made .app in the Staged directory

This runs when packaging a full made .app into Project/Binaries

This runs when packaging a .xcarchive for distribution

Gets the AppStoreConnect auth options for a given project. Will return empty string if the project isn't set up to use ASC

Generates a stub xcode project for the given project/platform/target combo, then builds or archives it

Project to build Platform to build The architecture we are targeting (really, this is for Simulator to pass in the -destination field) Configuration to build Target to build Sets an envvar used inside the xcode project to control certain features Any extra options to pass to xcodebuild If true, force signing with the - identity xcode's exit code

Genearate an run-only Xcode project, that is not meant to be used for anything else besides code-signing/running/etc of the native .app bundle

Location of .uproject file (or null for the engine project The platform to generate a project for The name of the target being built, so we can generate a more minimal project True if this is making a bild for uploading to app store Logging object Returns the .xcworkspace that was made

Version of FinalizeAppWithXcode that is meant for modern xcode mode, where we assume all codesigning is setup already in the project, so nothing else is needed

The .xcworkspace file to build THe platform to make the .app for The architecture we are targeting (really, this is for Simulator to pass in the -destination field) The name of the scheme (basically the target on the .xcworkspace) Which configuration to make (Debug, etc) Action (build, archive, etc) Extra options to pass to xcodebuild Logging object xcode's exit code

Pass along the call to UEBuildTarget.MakeBinaryFileName, but taking an extension instead of a binary type, since the type is hidden

FInds the latest .xcarchive for a given Target name (the .xcarchive will start with this name then have a data appended)

Name of the target to look for, this will be the prefix for the .xcarchive to search for If null, look in Xcode Archives library, otherwiwse, look here

Base class for Apple-based project generators

Utilities related to code sign for Apple Platforms

A logger

Constructor

The shared provision library directory (on PC)

Get the name from the Certificate

Get the friendly name from the Certificate

When receiving the cert tool process call

Finds all valid installed certificates

Finds all valid installed provisions

Tries to find a matching certificate on this machine from the the serial number of one of the certificates in the mobile provision (the one in the mobileprovision is missing the public/private key pair)

Makes sure the required files for code signing exist and can be found

Find the certs and provision

The XML doc

Helper for info plist

Set read only

constructor

Create plist from file

save the plist to file

Constructor

Convert value to plist format

Add key value pair

Add key value pair

Clones a dictionary from an existing .plist into a new one. Root should point to the dict key in the source plist.

Get String

Get date

Get bool

Process one node event

Process the value for the key

Merge two plists together. Whenever both have the same key, the value in the dominant source list wins.

Returns each of the entries in the value tag of type array for a given key If the key is missing, an empty array is returned. Only entries of a given type within the array are returned.

Returns true if the key exists (and has a value) and false otherwise

Remove the key value

Set the value for the key

Set the string

Save the string

Find a prefixable file (checks first with the prefix and then without it)

The path that the file should be in The filename to check for (with and without SigningPrefix prepended to it) The path to the most desirable file (may still not exist)

Finds the first file in the directory with a given extension (if it exists). This method is to provide some idiot-proofing (for example, .mobileprovision files, which will be expected to be saved from the website as GameName.mobileprovision or Distro_GameName.mobileprovision, but falling back to using the first one we find if the correctly named one is not found helps the user if they mess up during the process.

Find a prefixable file or directory (checks first with the prefix and then without it)

The path that the file should be in The name to check for (with and without SigningPrefix prepended to it) Is the desired name a directory? The path to the most desirable file (may still not exist)

The constructor

Get the string from the plist

Get the precompile source plist filename

Handle grabbing the initial plist

The mobile provision

Tag

ApplicationIdentifierPrefix

ApplicationIdentifier

DeveloperCertificates

ProvisionedDeviceIDs

ProvisionName

bDebugn

Data

CreationDate

ExpirationDate

FileName

UUID

The Platform

The logger

The constructor

Cache the mobile provisions

Clean the mobile provisions

Fond compatible provision

Extracts the dict values for the Entitlements key and creates a new full .plist file from them (with outer plist and dict keys as well as doctype, etc...)

Constructs a MobileProvision from an xml blob extracted from the real ASN.1 file

Does this provision contain the specified UDID?

This class understands how to get the embedded plist in a .mobileprovision file. It doesn't understand the full format and is not capable of writing a new one out or anything similar.

The mobile provision parser

Parse the file

Parse the file

Parse the file

The code signing config class

The display name in title bars, popups, etc ...

The game directory

The binaries directory

Optional Prefix to append to .xcent and .mobileprovision files, for handling multiple certificates on same source game

PCStagingRootDir

The local staging directory for files needed by Xcode on the Mac (on PC)

The staging directory from UAT that is passed into IPP (for repackaging, etc...)

The delta manifest for deploying files for iterative deploy

The files to be retrieved from the device

The project file that is passed into IPP from UAT

The device to deploy or launch on

Determine whether to use RPC Util or not

Optional override for the dev root on the target mac for remote builds.

Optional value specifying that we are working with tvOS

The local build directory (on PC)

The shared provision library directory (on PC)

The shared (Engine) build directory (on PC)

The local build intermediate directory (on PC)

The local directory cooked files are placed (on PC)

The local directory config files are placed (on PC)

The engine config files are placed (on PC)

The engine directory

The local directory that a payload (GameName.app) is assembled into before being copied to the Mac (on PC)

Program_Architecture

Program_GameName

Returns the name of the file containing user overrides that will be applied when packaging on PC

GetPlistOverrideFilename

Whether or not to output extra information (like every file copy and date/time stamp)

Whether or not to output extra information in code signing

Whether or not non-critical files will be packaged (critical == required for signing or .app validation, the app may still fail to run with only 'critical' files present). Also affects the name and location of the IPA back on the PC

Is this a distribution packaging build? Controls a number of aspects of packing (which signing prefix and provisioning profile to use, etc...)

Is this a c++ code based project? So far used on repackagefromstage to properly choose the .ipa name

Is this going to try automatic signing?

Whether or not to strip symbols (they will always be stripped when packaging for distribution)

Do a code signing update when repackaging?

Whether the cooked data will be cooked on the fly or was already cooked by the books.

Whether the install should be performed on a provision

provision to be installed

provision to be installed

provision to extract certificate for

target name specificied by the command line, if not set GameName + optional Client will be used

IOS Team ID to be used for automatic signing

Whether the install should be performed on a certificate

Certificate to be installed

Certificate to be output

An override server Mac name

A name to use for the bundle indentifier and display name when resigning

Whether to use None or Best for the compression setting when repackaging IPAs (int version of Ionic.Zlib.CompressionLevel) By making this an int, we are able to delay load the Ionic assembly from a different path (which is required)

If the requirements blob is present in the existing executable when code signing, should it be carried forward (true) or should a dummy requirements blob be created with no actual requirements (false)

The code signing identity to use when signing via RPC

The minimum OS version

Create an iterative IPA (i.e. a stub only with Icons and Splash images)

Returns a path to the place to back up documents from a device

The init

Public IOS functions exposed to UAT

Logger for output

Logger for output

Set a secondary remote Mac to retrieve built data on a remote Mac.

Prepare the build and project on a Remote Mac to be able to debug an iOS or tvOS package built remotely

TargetPlatform, iOS or tvOS Location of .uproject file A logger

Base class for platform-specific project generators

Constructor

Command line arguments passed to the project generator Logger for output

Enumerate all the platforms that this generator supports

If this is set, then we do not do any post-compile steps -- except moving the executable into the proper spot on Mac.

Which compiler\linker frontend to use

Which library archiver to use

Adds a build product and its associated debug file to a receipt.

Build product to add Type of build product

Generates debug info for a given executable

FileItem describing the executable to generate debug info for Was this build made with LTO enabled? List of actions to be executed. Additional actions will be added to this list. Logger for output

Generates pseudo pdb info for a given executable

FileItem describing the executable to generate debug info for List of actions to be executed. Additional actions will be added to this list.

Substrings that indicate a line contains an error

Helper function to sync source files to and from the local system and a remote Mac

Allows interrogating the contents of a .mobileprovision

The contents of the provision

Map of key names to XML elements holding their values

Constructor

XML file to create the mobile provision from. Call Read() to read from a signed file on disk.

Gets the unique id for this mobileprovision

UUID for the provision

Gets the bundle id for this mobileprovision

Bundle Identifier for the provision

Gets the team unique id for this mobileprovision

Receives the team unique id True if the team unique ID was found, false otherwise

Reads a mobileprovision from a file on disk

Path to the file New mobile provision instance

Reads the plist file inside a mobileprovision

Path to the file XML plist extracted from the mobile provision

IOS-specific target settings

Whether to strip iOS symbols or not (implied by Shipping config).

If true, then a stub IPA will be generated when compiling is done (minimal files needed for a valid IPA).

Whether to generate a native Xcode project as a wrapper for the framework.

Don't generate crashlytics data

Don't generate crashlytics data

Disables clang build verification checks on static libraries

Mark the build for distribution

Manual override for the provision to use. Should be a full path.

Imports the given certificate (inc private key) into a temporary keychain before signing.

Password for the imported certificate

Cached project settings for the target (set in ResetTarget)

Enables address sanitizer (ASan)

Enables thread sanitizer (TSan)

Enables undefined behavior sanitizer (UBSan)

Read-only wrapper for IOS-specific target settings

The private mutable settings object

Constructor

The settings object to wrap

Accessors for fields on the inner TargetRules instance

Stores project-specific IOS settings. Instances of this object are cached by IOSPlatform.

The cached project file location

Whether to build the iOS project as a framework.

Whether to generate a native Xcode project as a wrapper for the framework.

Whether to generate a dSYM file or not.

Whether to generate a dSYM bundle (as opposed to single file dSYM)

Whether to generate a dSYM file or not.

The minimum supported version

Whether to support iPhone

Whether to support iPad

additional linker flags for shipping

additional linker flags for non-shipping

mobile provision to use for code signing

signing certificate to use for code signing

true if notifications are enabled

true if notifications are enabled

true if notifications are enabled

true if iTunes file sharing support is enabled

The bundle identifier

true if using Xcode managed provisioning, else false

The IOS Team ID

true to change FORCEINLINE to a regular INLINE.

true if IDFA are enabled

true when building for distribution

override for the app's display name if different from the project name

longer display name than BundleName if needed

Which version of the iOS to allow at run time

which devices the game is allowed to run on

Constructor

The project file to read settings for Bundle identifier needed when project file is empty

Protected constructor. Used by TVOSProjectSettings.

The project file to read settings for The platform to read settings for Bundle identifier needed when project file is empty

IOS provisioning data

Determines if the given name is a build product for a target.

The name to check Target or application names that may appear at the start of the build product name (eg. "UnrealEditor", "ShooterGameEditor") Suffixes which may appear at the end of the build product name True if the string matches the name of a build product, false otherwise

Get the extension to use for the given binary type

The binary type being built string The binary extenstion (ie 'exe' or 'dll')

Check for the default configuration return true if the project uses the default build config

Check for the build requirement due to platform requirements return true if the project requires a build

Modify the rules for a newly created module, where the target is a different host platform. This is not required - but allows for hiding details of a particular platform.

The name of the module The module rules The target being build

Whether this platform should create debug information or not

The target being built bool true if debug info should be generated, false if not

Setup the target environment for building

Settings for the target being compiled The compile environment for this target The link environment for this target

Setup the binaries for this specific platform.

The target being built

Creates a toolchain instance for the given platform.

The target being built New toolchain instance.

Register the platform with the UEBuildPlatform class

Reads the GameName.PackageVersionCounter from disk and bumps the minor version number in it

Pulls apart a version string of one of the two following formats: "7301.15 11-01 10:28" (Major.Minor Date Time) "7486.0" (Major.Minor)

Parses the version string (expected to be of the form major.minor or major) Also parses the major.minor from the running version file and increments it's minor by 1. If the running version major matches and the running version minor is newer, then the bundle version is updated. In either case, the running version is set to the current bundle version number and written back out.

The (possibly updated) bundle version

Updates the minor version in the CFBundleVersion key of the specified PList if this is a new package. Also updates the key EpicAppVersion with the bundle version and the current date/time (no year)

Public Linux functions exposed to UAT

Logger for output

Platform name (embeds architecture for now)

Force using system compiler and error out if not possible

Whether to compile with the verbose flag

Whether to link with the verbose flag

Whether platform supports switching SDKs during runtime

true if supports

Returns a path to the internal SDK

Valid path to the internal SDK, null otherwise

Returns the in-tree root for the Linux Toolchain for this host platform.

Whether a host can use its system sdk for this platform

Returns the root SDK path for all architectures WARNING: Do not cache this value - it may be changed after sourcing OutputEnvVars.txt

Valid SDK string

Returns the SDK path for a specific architecture WARNING: Do not cache this value - it may be changed after sourcing OutputEnvVars.txt

Valid SDK DirectoryReference

Whether the path contains a valid clang version

Whether the required external SDKs are installed for this platform

Base class for platform-specific project generators

Constructor

Command line arguments passed to the project generator Logger for output

Enumerate all the platforms that this generator supports

Get clang toolchain version from full version string v17_clang-10.0.1-centos7 -> 10.0.1 v17_clang-16.0.1-centos7 -> 16

Full clang toolchain version string. Example: "v17_clang-10.0.1-centos7" Clang toolchain version. Example: 10.0.1 or 16 Starting with clang 16.x the directory naming changed to include major version only Flavor of the current build (will map to target triplet) Pass --gdb-index option to linker to generate .gdb_index section. Allows you to override the maximum binary size allowed to be passed to objcopy.exe when cross building on Windows. Max value is 2GB, due to bat file limitation Platform SDK to use

Architecture-specific compiler switches

Whether to use old, slower way to relink circularly dependent libraries. It makes sense to use it when cross-compiling on Windows due to race conditions between actions reading and modifying the libs.

Track which scripts need to be deleted before appending to

Holds all the binaries for a particular target (except maybe the executable itself).

Tracks that information about used C++ library is only printed once

Creates an action to archive all the .o files into single .a file

Linux-specific target settings

Constructor

Enables address sanitizer (ASan)

Enables LibFuzzer

Enables thread sanitizer (TSan)

Enables undefined behavior sanitizer (UBSan)

Enables memory sanitizer (MSan)

Whether or not to preserve the portable symbol file produced by dump_syms

Turns on tuning of debug info for LLDB

Whether to globally disable calling dump_syms

Enables runtime ray tracing support.

Read-only wrapper for Linux-specific target settings

Constructor

The settings object to wrap

Accessors for fields on the inner TargetRules instance

Linux host architecture (compiler target triplet) @todo Remove this and get the actual Host architecture?

SDK in use by the platform

Constructor

Determines if the given name is a build product for a target.

The name to check Target or application names that may appear at the start of the build product name (eg. "UnrealEditor", "ShooterGameEditor") Suffixes which may appear at the end of the build product name True if the string matches the name of a build product, false otherwise

Get the extension to use for the given binary type

The binary type being built string The binary extension (i.e. 'exe' or 'dll')

Get the extensions to use for debug info for the given binary type

Rules for the target being built The binary type being built string[] The debug info extensions (i.e. 'pdb')

Modify the rules for a newly created module, where the target is a different host platform. This is not required - but allows for hiding details of a particular platform.

The name of the module The module rules The target being build

Modify the rules for a newly created module, in a target that's being built for this platform. This is not required - but allows for hiding details of a particular platform.

The name of the module The module rules The target being build

Whether this platform should create debug information or not

The target being built bool true if debug info should be generated, false if not

Creates a toolchain instance for the given platform.

The target being built New toolchain instance.

Register the platform with the UEBuildPlatform class

Get the default deployment target version for the given target type. This will be put into the .plist file for runtime check Will be in the format A.B.C

Get the default build target version for the given target type. This will be passed to clang when compiling/linking Will be in the format AA.BB

Public Mac functions exposed to UAT

Describes the architecture of the host. Note - this ignores translation. IsRunningUnderRosetta can be used to detect that we're running under translation

Cached result for AppleArch check

Cached result for Rosetta check

Returns true if we're running under Rosetta

Returns true if we're running on Apple architecture (either natively which dotnet will do, or under Rosetta)

Strips symbols from a file

The input file The output file

Base class for platform-specific project generators

Constructor

Command line arguments passed to the project generator Logger for output

Register the platform with the UEPlatformProjectGenerator class

Which version of the Mac OS X to allow at run time

Minimum version of Mac OS X to actually run on, running on earlier versions will display the system minimum version error dialog and exit.

Constructor

Whether to output verbose logging Logger for output

Mac toolchain wrapper

Which compiler\linker frontend to use

Which archiver to use

Generates debug info for a given executable

FileItem describing the executable or dylib to generate debug info for List of actions to be executed. Additional actions will be added to this list. Logger for output

Creates app bundle for a given executable

FileItem describing the executable to generate app bundle for List of actions to be executed. Additional actions will be added to this list.

Mac-specific target settings

Enables address sanitizer (ASan).

Enables LibFuzzer.

Enables thread sanitizer (TSan).

Enables undefined behavior sanitizer (UBSan).

Enables the generation of .dsym files. This can be disabled to enable faster iteration times during development.

Disables clang build verification checks on static libraries

Enables runtime ray tracing support.

Read-only wrapper for Mac-specific target settings

The private mutable settings object

Constructor

The settings object to wrap

Accessors for fields on the inner TargetRules instance

Determines if the given name is a build product for a target.

The name to check Target or application names that may appear at the start of the build product name (eg. "UnrealEditor", "ShooterGameEditor") Suffixes which may appear at the end of the build product name True if the string matches the name of a build product, false otherwise

Get the extension to use for the given binary type

The binrary type being built string The binary extenstion (ie 'exe' or 'dll')

Get the extensions to use for debug info for the given binary type

Rules for the target being built The binary type being built string[] The debug info extensions (i.e. 'pdb')

Modify the rules for a newly created module, where the target is a different host platform. This is not required - but allows for hiding details of a particular platform.

The name of the module The module rules The target being build

For platforms that need to output multiple files per binary (ie Android "fat" binaries) this will emit multiple paths. By default, it simply makes an array from the input

Modify the rules for a newly created module, in a target that's being built for this platform. This is not required - but allows for hiding details of a particular platform.

The name of the module The module rules The target being build

Setup the target environment for building

Settings for the target being compiled The compile environment for this target The link environment for this target

Whether this platform should create debug information or not

The target being built true if debug info should be generated, false if not

Creates a toolchain instance for the given platform.

The target being built New toolchain instance.

Register the platform with the UEBuildPlatform class

Public TVOS functions exposed to UAT

Constructor

Command line arguments passed to the project generator Logger for output

Enumerate all the platforms that this generator supports

which devices the game is allowed to run on

Setup the target environment for building

Settings for the target being compiled The compile environment for this target The link environment for this target

Creates a toolchain instance for the given platform.

The target being built New toolchain instance.

Register the platform with the UEBuildPlatform class

Base class for VC appx manifest generation

config section for platform-specific target settings config section for platform-specific general target settings (i.e. settings with are unrelated to manifest generation) config section for general target settings default subdirectory for build resources default subdirectory for engine resources Manifest compliance values cached engine ini cached game ini AppX package resource generator the default culture to use lookup table for UE's CultureToStage StageId to AppX CultureId the platform to generate the manifest for project file to use target name to use Logger for output Whether we have logged the deprecation warning for PerCultureResources CultureId being replaced by StageIdOverrides CustomConfig to use when reading the ini files

Create a manifest generator for the given platform variant.

Returns a valid version of the given package version string

Returns a valid version of the given application id

Reads an integer from the cached ini files

Reads a string from the cached ini files

Reads a bool from the cached ini files

Reads a color from the cached ini files

Create all the localization data. Returns whether there is any per-culture data set up

Register the locations where resource binary files can be found

Get the resources element

Get the package identity name string

Get the publisher name string

Get the package version string

Get the package identity element

Updates the given package version to include the engine build version, if requested

Get the path to the makepri.exe tool

Get any additional platform-specific parameters for makepri.exe

Return the entire manifest element

Perform any platform-specific processing on the manifest before it is saved

Perform any additional initialization once all parameters and configuration are ready

Create a manifest and return the list of modified files

Cache of Visual C++ installation directories

Cache of Windows SDK installation directories

Cache of Universal CRT installation directories

Cache of Visual Studio installation directories

Cache of DIA SDK installation directories

Finds all the installed Windows SDK versions

Logger for output Map of version number to Windows SDK directories

List all the installed Windows SDK versions

Logger for output

Finds all the installed Universal CRT versions

Logger for output Map of version number to universal CRT directories

Determines the directory containing the Windows SDK toolchain

The desired Windows SDK version. This may be "Latest", a specific version number, or null. If null, the function will look for DefaultWindowsSdkVersion. Failing that, it will return the latest version. Logger for output Receives the version number of the selected Windows SDK Receives the root directory for the selected SDK Optional minimum required version. Ignored if DesiredVesrion is specified Optional maximum required version. Ignored if DesiredVesrion is specified True if the toolchain directory was found correctly

Updates the CachedWindowsSdkDirs and CachedUniversalCrtDirs variables

Enumerates all the Windows 10 SDK root directories

Receives all the Windows 10 sdk root directories Logger for output

Gets the installation directory for the NETFXSDK

Receives the installation directory on success True if the directory was found, false otherwise

Reads an install directory for a 32-bit program from a registry key. This checks for per-user and machine wide settings, and under the Wow64 virtual keys (HKCU\SOFTWARE, HKLM\SOFTWARE, HKCU\SOFTWARE\Wow6432Node, HKLM\SOFTWARE\Wow6432Node).

Path to the key to read, under one of the roots listed above. Value to be read. On success, the directory corresponding to the value read. True if the key was read, false otherwise.

For each root location relevant to install dirs, look for the given key and add its subkeys to the set of subkeys to return. This checks for per-user and machine wide settings, and under the Wow64 virtual keys (HKCU\SOFTWARE, HKLM\SOFTWARE, HKCU\SOFTWARE\Wow6432Node, HKLM\SOFTWARE\Wow6432Node).

The subkey to look for under each root location A list of unique subkeys found under any of the existing subkeys

Attempts to reads a directory name stored in a registry key

Key to read from Value within the key to read The directory read from the registry key True if the key was read, false if it was missing or empty

Gets the MSBuild path, and throws an exception on failure.

Path to MSBuild

Determines if a given compiler is installed

Compiler to check for Architecture the compiler must support Logger for output True if the given compiler is installed

Determines if a given compiler is installed and valid

Compiler to check for Architecture the compiler must support Logger for output True if the given compiler is installed and valid

Determines the directory containing the MSVC toolchain

Major version of the compiler to use The minimum compiler version to use Architecture that is required Logger for output Receives the chosen toolchain version Receives the directory containing the toolchain Receives the optional directory containing redistributable components True if the toolchain directory was found correctly

Returns the human-readable name of the given compiler

The compiler value Name of the compiler

Select which toolchain to use, combining a custom preference with a default sort order

Ordering function Architecture that must be supported

Dump all available toolchain info, combining a custom preference with a default sort order

Ordering function Architecture that must be supported The ILogger interface to write to

Dump all available toolchain info for a compiler

The compiler to filter by Architecture that must be supported The ILogger interface to write to

Read the Visual Studio install directory for the given compiler version. Note that it is possible for the compiler toolchain to be installed without Visual Studio, and vice versa.

List of directories containing Visual Studio installations

Read the Visual Studio install directory for the given compiler version. Note that it is possible for the compiler toolchain to be installed without Visual Studio, and vice versa.

List of directories containing Visual Studio installations

Finds all the valid Visual Studio toolchains under the given base directory

Base directory to search Optional directory for redistributable components (DLLs etc) The release channel of this installation Map of tool chain version to installation info Whether this folder contains AutoSDK entries Logger for output

Finds the most appropriate redist directory for the given toolchain version

Adds a Visual C++ toolchain to a list of installations

Add a Clang toolchain

Add an Intel OneAPI toolchain

Finds all the valid Intel oneAPI toolchains under the given base directory

Base directory to search Map of tool chain version to installation info Logger for output

Test whether an executable is 64-bit

Executable to test

The compiler host directory name for the running process architecture.

Determines if the given path is a valid Visual C++ version number

The toolchain directory The version number for the toolchain True if the path is a valid version

Checks if the given directory contains a 64-bit toolchain. Used to prefer regular Visual Studio versions over express editions.

Directory to check True if the given directory contains a 64-bit toolchain

Checks if the given directory contains an arm64 toolchain. Used to require arm64, which is an optional install item, when that is our target architecture.

Directory to check True if the given directory contains the arm64 toolchain

Checks if the given directory contains a arm64ec toolchain. Used to require arm64, which is an optional install item, when that is our target architecture.

Directory to check True if the given directory contains the arm64ec toolchain

Determines if an IDE for the given compiler is installed.

Compiler to check for Logger for output True if the given compiler is installed

Gets the path to MSBuild. This mirrors the logic in GetMSBuildPath.bat.

Logger for output On success, receives the path to the MSBuild executable. True on success.

Function to query the registry under HKCU/HKLM Win32/Wow64 software registry keys for a certain install directory. This mirrors the logic in GetMSBuildPath.bat.

Determines the directory containing the MSVC toolchain

Major version of the compiler to use Map of version number to directories

Determines if a directory contains a valid DIA SDK

The directory to check True if it contains a valid DIA SDK

The default compiler version to be used, if installed.

The minimum supported Clang compiler

Ranges of tested compiler toolchains to be used, in order of preference. If multiple toolchains in a range are present, the latest version will be preferred. Note that the numbers here correspond to the installation *folders* rather than precise executable versions.

Minimum Clang version required for MSVC toolchain versions

Tested compiler toolchains that should not be allowed.

The minimum supported MSVC compiler

The default compiler version to be used, if installed. https://www.intel.com/content/www/us/en/developer/articles/tool/oneapi-standalone-components.html#dpcpp-cpp

The minimum supported Intel compiler

If a toolchain version is a preferred version

The toolchain type The version number If the version is preferred

Get the latest preferred toolchain version

The toolchain type The version number

The minimum supported Clang version for a given MSVC toolchain

The base Clang version for a given Intel toolchain

Whether toolchain errors should be ignored. Enable to ignore banned toolchains when generating projects, as components such as the recommended toolchain can be installed by opening the generated solution via the .vsconfig file. If enabled the error will be downgraded to a warning.

The default set of components that should be suggested to be installed for Visual Studio This or the 2022 specific components should be updated if the preferred visual cpp version changes

Additional set of components that should be suggested to be installed for Visual Studio to support the Linux platform.

Additional set of components that should be suggested to be installed for Visual Studio 2022.

The minimum supported Visual Studio IDE version

Returns the list of suggested of components that should be suggested to be installed for Visual Studio. Used to generate a .vsconfig file which will prompt Visual Studio to ask the user to install these components.

Information about a particular toolchain installation

The version "family" (ie. the nominal version number of the directory this toolchain is installed to)

Index into the preferred version range

The actual version number of this toolchain

Whether this is a 64-bit toolchain

The release channel of this toolchain

The architecture of this ToolChainInstallation (multiple ToolChainInstallation instances may be created, one per architecture).

Reason for this toolchain not being compatible

Base directory for the toolchain

Base directory for the redistributable components

Whether this toolchain comes from AutoSDK.

Constructor

The release channel of this toolchain Base directory for the toolchain Optional directory for redistributable components (DLLs etc) Whether this toolchain comes from AutoSDK

Flags for the PVS analyzer mode

Check for 64-bit portability issues

Enable general analysis

Check for optimizations

Enable customer-specific rules

Enable MISRA analysis

Flags for the PVS analyzer timeout

Analisys timeout for file 10 minutes (600 seconds)

Analisys timeout for file 30 minutes (1800 seconds)

Analisys timeout for file 60 minutes (3600 seconds)

Analisys timeout when not set (a lot of seconds)

Partial representation of PVS-Studio main settings file

Masks for paths excluded for analysis

Registered username

Registered serial number

Disable the 64-bit Analysis

Disable the General Analysis

Disable the Optimization Analysis

Disable the Customer's Specific diagnostic rules

Disable the MISRA Analysis

File analysis timeout

Disable analyzer Level 3 (Low) messages

Enable the display of analyzer rules exceptions which can be specified by comments and .pvsconfig files.

Gets the analysis mode flags from the settings

Mode flags

Attempts to read the application settings from the default location

Application settings instance, or null if no file was present

Settings for the PVS Studio analyzer

Returns the application settings

Whether to use application settings to determine the analysis mode

Override for the analysis mode to use

Private storage for the mode flags

Override for the analysis timeoutFlag to use

Private storage for the analysis timeout

Override for the disable Level 3 (Low) analyzer messages

Private storage for the NoNoise analyzer setting

Override for the enable the display of analyzer rules exceptions which can be specified by comments and .pvsconfig files.

Private storage for the ReportDisabledRules analyzer setting

Read-only version of the PVS toolchain settings

Inner settings

Constructor

The inner object

Accessor for the Application settings

Whether to use the application settings for the mode

Override for the analysis mode to use

Override for the analysis timeout to use

Override NoNoise analysis setting to use

Override EnableReportDisabledRules analysis setting to use

Special mode for gathering all the messages into a single output file

Path to the input file list

Output file to generate

Path to file list of paths to ignore

The maximum level of warnings to print

Version of the analyzers

If all ThirdParty code should be ignored

Execute the command

List of command line arguments Always zero, or throws an exception

AppX Package Resource Index generator

Folders where binary resource files are located, in decreasing priority order

Folders where fallback binary resource files are located, in decreasing priority order

Target OS version

Create a new instance

Adds a reference to the given culture

Adds a reference to all of the given cultures

Returns a collection of all registered cultures

Add the given string to the default culture

Adds all of the given strings to the default culture

Add the given string to the given culture

Adds all of the given strings to the given culture

Returns whether the given string is known

Clear all stored strings for all cultures

Attempts to locate the given resource binary file in the previously-specified resource folders

Determines whether the given resource binary file can be found in one of the known folder locations for the given culture

Determines whether the given default resource binary file can be found in one of the known folder locations

Adds the given resource binary file(s) to the manifest files

Adds the given file to the manifest files

Copies all of the generated files to the output folder

Adds the given string to the culture string writers

Generate the package resource index and copies all resources files to the output

Intentionally unimplemented, but declared so that it's type can be included in generated resx files

Resource writer for VC app manifest generator

Create a new resource writer at the given path

Closes the writer

Add the given resource reference

Available compiler toolchains on Windows platform

Use the default compiler. A specific value will always be used outside of configuration classes.

Use Clang for Windows, using the clang-cl driver.

Use the RTFM (Rollback Transactions on Failure Memory) Clang variant for Verse on Windows, using the verse-clang-cl driver.

Use the Intel oneAPI C++ compiler

Visual Studio 2022 (Visual C++ 17.0)

Unsupported Visual Studio Must be the last entry in WindowsCompiler enum and should only be used in limited circumstances

Enum describing the release channel of a compiler

Extension methods for WindowsCompiler enum

Returns if this compiler toolchain based on Clang

The compiler to check true if Clang based

Returns if this compiler toolchain based on Intel

The compiler to check true if Intel based

Returns if this compiler toolchain based on MSVC

The compiler to check true if MSVC based

Windows-specific target settings

The target rules which owns this object. Used to resolve some properties.

If enabled will set the ProductVersion embeded in windows executables and dlls to contain BUILT_FROM_CHANGELIST and BuildVersion Enabled by default for all precompiled and Shipping configurations. Regardless of this setting, the versions from Build.version will be available via the BuildSettings module Note: Embedding these versions will cause resource files to be recompiled whenever changelist is updated which will cause binaries to relink

If -PGOOptimize is specified but the linker flags have changed since the last -PGOProfile, this will emit a warning and build without PGO instead of failing during link with LNK1268.

If specified along with -PGOProfile, then /FASTGENPROFILE will be used instead of /GENPROFILE. This usually means that the PGO data is generated faster, but the resulting data may not yield as efficient optimizations during -PGOOptimize

If specified along with -PGOOptimize, will use the specified per-merged pgd file instead of the usual pgd file with loose pgc files.

If specified along with -PGOProfile, prevent the usage of extra counters. Please note that by default /FASTGENPROFILE doesnt use extra counters

genprofile-fastgenprofile-generate-profiling-instrumented-build

If specified along with -PGOProfile, use sample-based PGO instead of instrumented. Currently Intel oneAPI 2024.0+ only.

Which level to use for Inline Function Expansion when TargetRules.bUseInlining is enabled

ob-inline-function-expansion

Version of the compiler toolchain to use on Windows platform. A value of "default" will be changed to a specific version at UBT start up.

Version of the toolchain to use on Windows platform when a non-msvc Compiler is in use, to locate include paths etc.

Architecture of Target.

Warning level when reporting toolchains that are not in the preferred version list

The specific compiler version to use. This may be a specific version number (for example, "14.13.26128"), the string "Latest" to select the newest available version, or the string "Preview" to select the newest available preview version. By default, and if it is available, we use the toolchain version indicated by WindowsPlatform.DefaultToolChainVersion (otherwise, we use the latest version).

The specific msvc toolchain version to use if the compiler is not msvc. This may be a specific version number (for example, "14.13.26128"), the string "Latest" to select the newest available version, or the string "Preview" to select the newest available preview version. By default, and if it is available, we use the toolchain version indicated by WindowsPlatform.DefaultToolChainVersion (otherwise, we use the latest version).

True if /fastfail should be passed to the msvc compiler and linker

True if /d2ExtendedWarningInfo should be passed to the compiler and /d2:-ExtendedWarningInfo to the linker

True if optimizations to reduce the size of debug information should be disabled See https://clang.llvm.org/docs/UsersManual.html#cmdoption-fstandalone-debug for more information

True if we should use the Clang linker (LLD) when we are compiling with Clang or Intel oneAPI, otherwise we use the MSVC linker.

The specific Windows SDK version to use. This may be a specific version number (for example, "8.1", "10.0" or "10.0.10150.0"), or the string "Latest", to select the newest available version. By default, and if it is available, we use the Windows SDK version indicated by WindowsPlatform.DefaultWindowsSdkVersion (otherwise, we use the latest version).

Value for the WINVER macro, defining the minimum supported Windows version.

Value for the NTDDI_VERSION macro, defining the minimum supported Windows version. https://learn.microsoft.com/en-us/windows/win32/winprog/using-the-windows-headers?redirectedfrom=MSDN#macros-for-conditional-declarations

Enable PIX debugging (automatically disabled in Shipping and Test configs)

Enable building with the Win10 SDK instead of the older Win8.1 SDK

Enable building with the C++/WinRT language projection

Enables runtime ray tracing support.

The name of the company (author, provider) that created the project.

The project's copyright and/or trademark notices.

The product name.

Enables address sanitizer (ASan). Only supported for Visual Studio 2019 16.7.0 and up.

Enables LibFuzzer. Only supported for Visual Studio 2022 17.0.0 and up.

Whether .sarif files containing errors and warnings are written alongside each .obj, if supported

Whether we should export a file containing .obj to source file mappings.

Whether to have the linker or library tool to generate a link repro in the specified directory See https://learn.microsoft.com/en-us/cpp/build/reference/linkrepro for more information

Provides a Module Definition File (.def) to the linker to describe various attributes of a DLL. Necessary when exporting functions by ordinal values instead of by name.

Specifies the path to a manifest file for the linker to embed. Defaults to the manifest in Engine/Build/Windows/Resources. Can be assigned to null if the target wants to specify its own manifest.

Specifies the path to an .ico file to use as the appliction icon. Can be assigned to null and will default to Engine/Build/Windows/Resources/Default.ico for engine targets or Build/Windows/Application.ico for projects.

Enables strict standard conformance mode (/permissive-).

Enables updated __cplusplus macro (/Zc:__cplusplus).

Enables inline conformance (Remove unreferenced COMDAT) (/Zc:inline).

Enables new preprocessor conformance (/Zc:preprocessor). This is always enabled for C++20 modules.

Enables enum types conformance (/Zc:enumTypes) in VS2022 17.4 Preview 4.0+.

Enables enforcing standard C++ ODR violations (/Zc:checkGwOdr) in VS2022 17.5 Preview 2.0+

Volatile Metadata is enabled by default and improves x64 emulation on arm64, but may come at a small perfomance cost (/volatileMetadata-).

Whether to request the linker create a stripped pdb file as part of the build. If enabled the full debug pdb will have the extension .full.pdb

If you supply -NoDebugInfo, windows platforms still create debug info while linking. Set this to true to not create debug info while linking in this circumstance

Set page size to allow for larger than 4GB PDBs to be generated by the msvc linker. Will default to 16384 for monolithic editor builds. Values should be a power of two such as 4096, 8192, 16384, or 32768

Specify an alternate location for the PDB file. This option does not change the location of the generated PDB file, it changes the name that is embedded into the executable. Path can contain %_PDB% which will be expanded to the original PDB file name of the target, without the directory. See https://learn.microsoft.com/en-us/cpp/build/reference/pdbaltpath-use-alternate-pdb-path

VS2015 updated some of the CRT definitions but not all of the Windows SDK has been updated to match. Microsoft provides legacy_stdio_definitions library to enable building with VS2015 until they fix everything up.

The stack size when linking

The stack size to commit when linking

Max number of slots FWindowsPlatformTLS::AllocTlsSlot can allocate.

Max number threads that can use FWindowsPlatformTLS at one time.

Determines the amount of memory that the compiler allocates to construct precompiled headers (/Zm).

Allow the target to specify extra options for linking that aren't otherwise noted here

Create an image that can be hot patched (/FUNCTIONPADMIN)

Strip unreferenced symbols (/OPT:REF)

Merge identical COMDAT sections together (/OPT:ICF)

Whether to put global symbols in their own sections (/Gw), allowing the linker to discard any that are unused.

Whether to reduce optimizations for huge functions over an instruction threshold to improve compile time https://devblogs.microsoft.com/cppblog/msvc-backend-updates-in-visual-studio-2019-versions-16-3-and-16-4/

The instruction threshold to use when reducing optimizations for huge functions, default 20000.

(Experimental) Appends the -ftime-trace argument to the command line for Clang to output a JSON file containing a timeline for the compile. See http://aras-p.info/blog/2019/01/16/time-trace-timeline-flame-chart-profiler-for-Clang/ for more info.

Outputs compile timing information so that it can be analyzed.

Print out files that are included by each source file

Bundle a working version of dbghelp.dll with the application, and use this to generate minidumps. This works around a bug with the Windows 10 Fall Creators Update (1709) where rich PE headers larger than a certain size would result in corrupt minidumps.

Whether this build will use Microsoft's custom XCurl instead of libcurl Note that XCurl is not part of the normal Windows SDK and will require additional downloads

Settings for PVS studio

The Visual C++ environment to use for this target. Only initialized after all the target settings are finalized, in ValidateTarget().

Directory containing the NETFXSDK

Directory containing the DIA SDK

Directory containing the IDE package (Professional, Community, etc...)

Directory containing ThirdParty DirectX

Directory containing ThirdParty DirectX libs

Directory containing ThirdParty DirectX dlls

When using a Visual Studio compiler, returns the version name as a string

The Visual Studio compiler version name (e.g. "2022")

Determines if a given compiler is installed and valid

Compiler to check for Architecture the compiler must support Logger for output True if the given compiler is installed and valid

Constructor

The target rules which owns this object

Read-only wrapper for Windows-specific target settings

The private mutable settings object

Constructor

The settings object to wrap

Accessors for fields on the inner TargetRules instance

Information about a particular Visual Studio installation

Compiler type

Version number for this installation

Base directory for the installation

Whether it's a community edition of Visual Studio.

The release channel of this installation

Constructor

Constructor

Creates a windows platform with the given enum value The installed Windows SDK Logger instance

Constructor that takes an archConfig (for use by subclasses)

Creates a windows platform with the given enum value The installed Windows SDK Achitecture configuration Logger instance

Reset a target's settings to the default

Creates the VCEnvironment object used to control compiling and other tools. Virtual to allow other platforms to override behavior

Stanard target object

Validate a target's settings

Gets the default compiler which should be used, if it's not set explicitly by the target, command line, or config file.

The default compiler version

Returns the human-readable name of the given compiler

The compiler value Name of the compiler

Get the first Visual Studio install directory for the given compiler version. Note that it is possible for the compiler toolchain to be installed without Visual Studio.

Version of the toolchain to look for. Logger for output True if the directory was found, false otherwise.

Determines if a given compiler is installed and valid

Compiler to check for Architecture the compiler must support Logger for output True if the given compiler is installed and valid

Determines the directory containing the MSVC toolchain

Major version of the compiler to use The minimum compiler version to use Architecture that is required Logger for output Receives the chosen toolchain version Receives the directory containing the toolchain Receives the optional directory containing redistributable components True if the toolchain directory was found correctly

Determines if a directory contains a valid DIA SDK

The directory to check True if it contains a valid DIA SDK

Gets the platform name that should be used.

If this platform can be compiled with SN-DBS

If this platform can be compiled with FASTBuild

Determines if the given name is a build product for a target.

The name to check Target or application names that may appear at the start of the build product name (eg. "UnrealEditor", "ShooterGameEditor") Suffixes which may appear at the end of the build product name True if the string matches the name of a build product, false otherwise

Get the extension to use for the given binary type

The binrary type being built string The binary extenstion (ie 'exe' or 'dll')

Get the extensions to use for debug info for the given binary type

The target being built The binary type being built string[] The debug info extensions (i.e. 'pdb')

Modify the rules for a newly created module, where the target is a different host platform. This is not required - but allows for hiding details of a particular platform.

The name of the module The module rules The target being build

Gets the application icon for a given project

The project file The icon to use for this project

Gets the application icon for a given project

The project file The icon to use for this project

Modify the rules for a newly created module, in a target that's being built for this platform. This is not required - but allows for hiding details of a particular platform.

The name of the module The module rules The target being build

Setup the target environment for building

Settings for the target being compiled The compile environment for this target The link environment for this target

Setup the configuration environment for building

The target being built The global compile environment The global link environment

Whether this platform should create debug information or not

The target being built bool true if debug info should be generated, false if not

Creates a toolchain instance for the given platform.

The target being built New toolchain instance.

Allows the platform to return various build metadata that is not tracked by other means. If the returned string changes, the makefile will be invalidated.

The project file being built String builder to contain build metadata

Deploys the given target

Receipt for the target being deployed

Allows the platform header name to be overridden to differ from the platform name.

Register the platform with the UEBuildPlatform class

Interface for an action that compiles C++ source code

Path to the compiled module interface file

Serializer which creates a portable object file and allows caching it

The action type

Artifact support for this step

Path to the compiler

The type of compiler being used

The version of the compiler being used

Source file to compile

The object file to output

The assembly file to output

The output preprocessed file

The output analyze warning and error log file

The output experimental warning and error log file

The dependency list file

Compiled module interface

For C++ source files, specifies a timing file used to track timing information.

Response file for the compiler

The precompiled header file

The precompiled header file

The header which matches the PCH

List of include paths

List of system include paths

List of macro definitions

List of force included files

Every file this action depends on. These files need to exist and be up to date in order for this action to even be considered

The files that this action produces after completing

Arguments to pass to the compiler

Whether to show included files to the console

Whether to override the normal logic for UsingClFilter and force it on.

Architecture this is compiling for (used for display)

Whether this compile is static code analysis (used for display)

Items that should be deleted before running this action

Root paths for this action (generally engine root project root, toolchain root, sdk root)

Whether to use cl-filter

Constructor

Compiler executable

Copy constructor

Action to copy from

Serialize a cache handler from an archive

Reader to serialize from

Writes the response file with the action's arguments

The graph builder Logger for output

Serializer for instances

Stores information about a Visual C++ installation and compile environment

The compiler version

The compiler directory

The compiler version

The compiler Architecture

The underlying toolchain to use. Using Clang/ICL will piggy-back on a Visual Studio toolchain for the CRT, linker, etc...

Root directory containing the toolchain

The toolchain version number

Root directory containing the Windows Sdk

Version number of the Windows Sdk

Use the CPP/WinRT language projection

Allow use of Clang linker

The path to the compiler for compiling code

The path to the linker for linking executables

The path to the linker for linking libraries

Path to the resource compiler from the Windows SDK

The path to the toolchain compiler for compiling code

Optional directory containing redistributable items (DLLs etc)

The default system include paths

The default system library paths

Constructor

Main constructor parameters Logger for output

Updates environment variables needed for running with this toolchain

Gets the path to the tool binaries.

Base directory for the VC toolchain Target Architecture Directory containing the 64-bit toolchain binaries

Gets the path to the compiler.

Gets the path to the linker.

Gets the path to the library linker.

Gets the path to the resource compiler.

Return the standard Visual C++ library path.

Sets up the standard compile environment for the toolchain

Creates an environment with the given settings

The compiler version to use The toolchain version to use, when a non-msvc compiler is used The platform to target The Architecture to target The specific compiler version to use The specific toolchain version to use (if the compiler isn't msvc) Version of the Windows SDK to use If specified, this is the SDK directory to use, otherwise, attempt to look up via registry. If specified, the WindowsSdkVersion is used directly Include the CPP/WinRT language projection Allow use of Clang linker Logger for output New environment object with paths for the given settings

Creates an environment with the given parameters

Parameter structure for constructing VCEnvironment

The platform to find the compiler for

The compiler to use

The compiler directory

The compiler version number

The compiler Architecture

The base toolchain version

Directory containing the toolchain

Version of the toolchain

Root directory containing the Windows Sdk

Version of the Windows Sdk

Optional directory for redistributable items (DLLs etc)

Include the CPP/WinRT language projection

Allow use of Clang linker

Creates VC environment construction parameters with the given settings

The compiler version to use The toolchain version to use, when a non-msvc compiler is used The platform to target The Architecture to target The specific compiler version to use The specific toolchain version to use (if the compiler isn't msvc) Version of the Windows SDK to use If specified, this is the SDK directory to use, otherwise, attempt to look up via registry. If specified, the WindowsSdkVersion is used directly Include the CPP/WinRT language projection Allow use of Clang linker Logger for output Creation parameters for VC environment

Caches predefined state ("prelude") for compiler versions and options

Set of options which can influence the prelude state. Any options matching entries in this set will be used to generate a separate prelude file.

Object used for ensuring only one thread can create items in the cache at once

File containing a list of macros to be used to generate a prelude file

Base directory for the cache

The parsed list of macros

Path to the file used to generate prelude headers

Cached mapping from compiler filename to its version string

Get the prelude file (or create it) for the given compiler executable and set of options

Path to the compiler executable Command line arguments for generating the prelude file Path to the prelude file

Creates a prelude header

Path to the file to create Path to the compiler Version number of the compiler Command line arguments used to generate the header

The target being built

The Visual C++ environment

Prepares the environment for building

Returns the version info for the toolchain. This will be output before building.

String describing the current toolchain

Macros passed via the command line have their quotes stripped, and are tokenized before being re-stringized by the compiler. This conversion back and forth is normally ok, but certain characters such as single quotes must always be paired. Remove any such characters here.

The macro value The sanitized value

Gets the default include paths for the given platform.

Public Linux functions exposed to UAT

Tries to get the directory for an installed Visual Studio version

The compiler version True if successful

Gets the path to MSBuild.exe

Path to MSBuild.exe

Returns the architecture name of the current architecture.

The architecture enum String with the name

Tries to get the directory for an installed Windows SDK

Receives the desired version on success Version of SDK Path to SDK root folder String with the name

Gets a list of Windows Sdk installation directories, ordered by preference

String with the name

Enumerates all the Windows 10 SDK root directories

Receives all the Windows 10 sdk root directories Logger for output

Base class for platform-specific project generators

Constructor

Command line arguments passed to the project generator Logger for output

Contains the name of an identifier. Individual objects are unique.

The name of this identifier

Global map of name to identifier instance

Constructor

Name of this identifier

Finds or adds an identifier with the given name

Name of the identifier New Identifier instance

Compares this identifier to another identifier

Identifier to compare to Value indicating which identifier should sort first

Formats this identifier as a string for debugging

Name of this identifier

Well known predefined identifiers

Helper functions for serialization

Read an identifier from a binary archive

Reader to serialize data from Instance of the serialized identifier

Write an identifier to a binary archive

Writer to serialize data to Identifier to write

Exception class for the preprocessor, which contains the file and position of the code causing an error

The context when the error was encountered

Constructor

The current preprocesor context Format string, to be passed to String.Format Optional argument list for the format string

Implementation of a C++ preprocessor.

Type of an include path

Regular include path, enclosed by quotes

System include path, enclosed by angle brackets

Include paths to look in

Framework paths to look in

Set of all included files with the #pragma once directive

Set of any files that has been processed

The current state of the preprocessor

Predefined token containing the constant "0"

Predefined token containing the constant "1"

Value of the __COUNTER__ variable

List of files included by the preprocessor

Enumerable of processed files

Default constructor

Determines whether the current preprocessor branch is active

True if the current branch is active

Defines a macro. May have an optional '=Value' suffix.

Macro to define

Defines a macro

Name of the macro String to be parsed for the macro's value

Defines a macro

The macro definition

Adds an include path to the preprocessor

The include path

Adds an include path to the preprocessor

The include path

Adds an include path to the preprocessor

The include path

Adds a framework path to the preprocessor

The framework path

Adds a framework path to the preprocessor

The framework path

Adds a framework path to the preprocessor

The framework path

Try to resolve an quoted include against the list of include directories. Uses search order described by https://msdn.microsoft.com/en-us/library/36k2cdd4.aspx.

The current preprocessor context The path appearing in an #include directive Specifies rules for how to resolve the include path (normal/system) If found, receives the resolved file True if the The resolved file

Try to resolve an quoted include against the list of include directories. Uses search order described by https://msdn.microsoft.com/en-us/library/36k2cdd4.aspx.

The base directory to search from Fragments of the relative path to follow The file that was found, if successful True if the The resolved file

Parses a file recursively

File to parse Lists of fragments that are parsed Outer context information, for error messages Cache for source files Logger for output Show all the included files, in order Suppress exceptions if an include path can not be resolved

Parse an include directive and resolve the file it references

Markup for the include directive Current preprocessor context Suppress exceptions if an include path can not be resolved Included file

Parse a source file fragment, using cached transforms if possible

The source file being parsed Fragment to parse Current preprocessor context

Validate and add a macro using the given parameter and token list

The current preprocessor context Name of the macro Parameter list for the macro List of tokens

Set a predefined macro to a given value

Name of the macro Type of the macro token Value of the macro The created macro

Parse a marked up directive from a file

The markup type Tokens for the directive The context that this markup is being parsed in

Read a macro definition

List of tokens in the directive The context that this directive is being parsed in

Parse an #undef directive

List of tokens in the directive The context that this directive is being parsed in

Parse an #if directive

List of tokens in the directive The context that this directive is being parsed in

Parse an #ifdef directive

List of tokens in the directive The context that this directive is being parsed in

Parse an #ifndef directive

List of tokens for this directive The context that this directive is being parsed in

Parse an #elif directive

List of tokens for this directive The context that this directive is being parsed in

Parse an #else directive

List of tokens in the directive The context that this directive is being parsed in

Parse an #endif directive

List of tokens in the directive The context that this directive is being parsed in

Parse a #pragma directive

List of tokens in the directive The context that this directive is being parsed in

Expand macros in the given sequence.

Sequence of input tokens List to receive the expanded tokens Whether a conditional expression is being evaluated (and 'defined' expressions are valid) The context that this directive is being parsed in

Expand macros in the given sequence, ignoring previously expanded macro names from a list.

Sequence of input tokens List to receive the expanded tokens Whether a conditional expression is being evaluated (and 'defined' expressions are valid) List of macros to ignore The context that this directive is being parsed in

Merges an optional leading space flag into the given token (recycling the original token if possible).

The token to merge a leading space into The leading space flag New token with the leading space flag set, or the existing token

Read a token from an enumerator and substitute it if it's a macro or 'defined' expression (reading more tokens as necessary to complete the expression).

The enumerator of input tokens List to receive the expanded tokens Whether a conditional expression is being evaluated (and 'defined' expressions are valid) List of macros to ignore The context that this directive is being parsed in Result from calling the enumerator's MoveNext() method

Gets a string for the __FILE__ macro

Context to scan to find the current file String representing the current context

Gets a string for the current file

Context to scan to find the current file Current source file being parsed

Gets the current line number

Context to scan to find the current file Line number in the first file encountered

Expand an object macro

The functional macro The list to receive the output tokens Whether the macro is being expanded in a conditional context, allowing use of the 'defined' keyword List of macros currently being expanded, which should be ignored for recursion The context that this directive is being parsed in

Expand a function macro

The functional macro Identifiers for each argument token The list to receive the output tokens Whether the macro is being expanded in a conditional context, allowing use of the 'defined' keyword List of macros currently being expanded, which should be ignored for recursion The context that this macro is being expanded

Appends a list of tokens to another list, setting the leading whitespace flag to the given value

List to receive the appended tokens List of tokens to append Whether there is space before the first token

Copies a single token from one list of tokens to another, or if it's an opening parenthesis, the entire subexpression until the closing parenthesis.

The input token list First token index in the input token list. Set to the last uncopied token index on return. List to recieve the output tokens True if a balanced expression was read, or false if the end of the list was encountered before finding a matching token

Copies a single token from one list of tokens to another, or if it's an opening parenthesis, the entire subexpression until the closing parenthesis.

The input token list List to recieve the output tokens The context that the parser is in True if a balanced expression was read, or false if the end of the list was encountered before finding a matching token

Represents a context that the preprocessor is working in. Used to form error messages, and determine things like the __FILE__ and __LINE__ directives.

The outer context

Constructor

The outer context

Context for a command line argument

Constructor

Formats this context for error messages

String describing this context

Represents a context that the preprocessor is reading from

The source file being read

The directory containing this file. When searching for included files, MSVC will check this directory.

Index of the current markup object being processed

Index of the next fragment to be read

Constructor

The source file being parsed The outer context

Format this file for the debugger, and error messages

Class to allow evaluating a preprocessor expression

Precedence table for binary operators (indexed by TokenType). Lower values indicate higher precedence.

Static constructor. Initializes the Precedence table.

Evaluate a preprocessor expression

The current preprocessor context List of tokens in the expression Value of the expression

Evaluates a ternary expression (a? b :c)

The current preprocessor context List of tokens in the expression Index into the token list of the next token to read Value of the expression

Recursive path for evaluating a sequence of binary operators, given a known LHS. Implementation of the shunting yard algorithm.

The current preprocessor context List of tokens in the expression Index into the token list of the next token to read The LHS value for the binary expression Minimum precedence value to consume Value of the expression

Evaluates a unary expression (+, -, !, ~)

The current preprocessor context List of tokens in the expression Index into the token list of the next token to read Value of the expression

Evaluates a primary expression

The current preprocessor context List of tokens in the expression Index into the token list of the next token to read Value of the expression

Parse a numeric literal from the given token

The current preprocessor context The utf-8 literal characters The literal value of the token

Checks whether the given literal has a valid integer suffix, starting at the given position

The literal token Index within the literal to start reading The literal value of the token

Stores information about a defined preprocessor macro

Name of the macro

Parameter names for the macro. The '...' placeholder is represented by the __VA_ARGS__ string.

Raw list of tokens for this macro

Construct a preprocessor macro

Name of the macro Parameter list for the macro. Should be null for object macros. Ownership of this list is transferred. Tokens for the macro. Ownership of this list is transferred.

Read a macro from a binary archive

Reader to serialize from

Write a macro to a binary archive

Writer to serialize to

Finds the index of a parameter in the parameter list

Parameter name to look for Index of the parameter, or -1 if it's not found.

Checks whether this macro definition is equivalent to another macro definition

The macro definition to compare against True if the macro definitions are equivalent

True if the macro is an object macro

True if the macro is a function macro

The number of required parameters. For variadic macros, the last parameter is optional.

True if the macro has a variable argument list

Converts this macro to a string for debugging

The tokens in this macro

Flags indicating the state of each nested conditional block in a stack.

The current conditional branch is active.

A branch within the current conditional block has been taken. Any #else/#elif blocks will not be taken.

The #else directive for this conditional block has been encountered. An #endif directive is expected next.

The first condition in this branch was an #if directive (as opposed to an #ifdef or #ifndef directive)

The first condition in this branch was an #if directive (as opposed to an #ifdef or #ifndef directive)

The first condition in this branch was an #ifndef directive (as opposed to an #ifdef or #if directive)

The branch has an #elif directive

Marshals access to the preprocessor state, ensuring that any changes are tracked within the active transform

Stack of conditional branch states

Mapping of name to macro definition

The current transform. Any queries or state modifications will be recorded in this.

Enumerates the current branches. Do not use this for decision logic; any dependencies will not be tracked.

Enumerates the current macros. Do not use this for decision logic; any dependencies will not be tracked.

Initialize an empty preprocessor state

Duplicates another preprocessor state. Throws an exception if a transform is currently being built in the other state.

The preprocessor state to copy

Create a new transform object, and assign it to be current

The new transform object

Detach the current transform

The transform object

Sets a flag indicating that a #pragma once directive was encountered

Set a macro to a specific definition

Macro definition

Checks if a macro with the given name is defined

The macro name True if the macro is defined

Removes a macro definition

Name of the macro

Attemps to get the definition for a macro

Name of the macro Receives the macro definition, or null if it's not defined True if the macro is defined, otherwise false

Pushes the preprocessor branch onto the stack

The branch state

Pops a preprocessor branch from the stack

The popped branch state

Attempts to pops a preprocessor branch from the stack

On success, receives the preprocessor branch state True if a branch was active, else false

Determines if the branch that the preprocessor is in is active

True if the branch is active, false otherwise

Determines if the given transform can apply to the current preprocessor state

The transform to test True if the transform can be applied to the current state

Apply the given transform to the current preprocessor state

The transform to apply True if the transform was applied to the current state

Tracks dependencies for transforming the current preprocessor state

Whether the preprocessor must be in an active state after the branches below are popped. This cannot be treated as a 'pop', because it might be the global scope.

List of branch states that will be popped from the stack

Map of macro name to their required value

List of new branches that will be pushed onto the stack

List of new macros that will be defined

This fragment contains a pragma once directive

Constructor

Reads a transform from disk

Archive to serialize from

Writes a transform to disk

Archive to serialize to

Encapsulates metadata for a C++ source file

The corresponding file item

Hash of the source file data

Last write time of this file when constructed

Markup dividing up this source file

Macro which is defined as part of the header guard. If this macro is defined, we don't need to include the header more than once.

Parsed fragments in this file. Only set for files which are being optimized.

Gets the location of this file

Construct a SourceFile from a file on disk

Location of the file

Construct a SourceFile from a raw byte array

Location of the file Contents of the file

Read a source file from a binary reader

The reader to serialize from

Read a source file from a binary reader

The reader to serialize to

Reads the contents of a file into a buffer, with a null terminator

Location of the file Array of bytes, with a null terminator

Converts a buffer from a given encoding to UTF8, appending a null terminator

The source data Length of the data in the source buffer Array of utf-8 encoded characters, with a null terminator

Converts a buffer from a given encoding to UTF8, appending a null terminator

The encoding to convert from The source data Length of the data in the source buffer Array of utf-8 encoded characters, with a null terminator

Checks whether the markup matches a C-style header guard

Converts a source file to a string for debugging

The full path to the file

Represents an fragment of a source file consisting of a sequence of includes followed by some arbitrary directives or source code.

The file that this fragment is part of

Index into the file's markup array of the start of this fragment (inclusive)

Index into the file's markup array of the end of this fragment (exclusive). Set to zero for external files.

List of known transforms for this fragment

Constructor

The source file that this fragment is part of Index into the file's markup array of the start of this fragment (inclusive) Index into the file's markup array of the end of this fragment (exclusive)

Constructor

The source file that this fragment is part of Reader to deserialize this object from

Write this fragment to an archive

The writer to serialize to

Summarize this fragment for the debugger

String representation of this fragment for the debugger

Possible types of source file markup

A span of tokens which are not preprocessor directives

An #include directive

A #define directive

An #undef directive

An #if directive

An #ifdef directive

An #ifndef directive

An #elif directive

An #else directive

An #endif directive

A #pragma directive

An #error directive

A #warning directive

An empty '#' on a line of its own

Some other directive

Base class for an annotated section of a source file

The directive corresponding to this markup

The one-based line number of this markup

The tokens parsed for this markup. Set for directives.

Construct the annotation with the given range

The type of this directive The line number of this markup List of tokens

Constructs a markup object using data read from an archive

The reader to deserialize from

Serializes this object to a binary archive

Writer to serialize to

Determines if this markup indicates a conditional preprocessor directive

True if this object is a conditional preprocessor directive

How this condition modifies the condition depth. Opening "if" statements have a value of +1, "endif" statements have a value of -1, and "else" statements have a value of 0.

Generate a string describing this annotation

String representation for debugging

Create markup for the given file

Reader for tokens in the file Array of markup objects which split up the given text buffer

Flags for a single token

No flags

The token has space before it

Do not replace any instances of this token with the corresponding macro.

Enumeration for token types

Single lexical token

Static token names

Contains the type of the token

Properties for this token

If this token is identifier, contains the identifier name

If this token is a literal, contains the raw utf-8 representation of it.

Constructor

The token type Flags for this token

Constructor

The token identifier Flags for this token

Constructs a literal token

Constructs a literal token

Reads a token from a binary archive

Archive to read from

Writes a token to a binary archive

The writer to serialize to

Checks if a token is equal to another object

The object to compare against True if the objects are equal, false otherwise

Checks if two tokens are equivalent

The object to compare against True if the tokens are equal, false otherwise

Compares two tokens for equality

The first token to compare The second token to compare True if the objects are equal, false otherwise

Compares two tokens for inequality

The first token to compare The second token to compare True if the objects are not equal, false otherwise

Gets a hash code for this object

Hash code for the object

Text corresponding to this token

Returns a new token with different flags

Flags to add from the token New token with updated flags

Returns a new token with different flags

Flags to remove from the token New token with updated flags

Accessor for whether this token has leading whitespace

Checks whether two tokens match

The token to compare against True if the tokens match, false otherwise

Determines whether the given token type is a literal

The type to test True if the given type is a literal

Concatenate a sequence of tokens into a string

The sequence of tokens to concatenate String containing the concatenated tokens

Concatenate a sequence of tokens into a string

The sequence of tokens to concatenate Receives the formatted string

Concatenate two tokens together

The first token The second token Current preprocessor context The combined token

Static constructor. Initializes the StaticTokens array.

Helper functions for serialization

Read a token from a binary archive

Reader to serialize data from Token read from the archive

Write a token to a binary archive

Writer to serialize data to Token to write

Tokenizer for C++ source files. Provides functions for navigating a source file skipping whitespace, comments, and so on when required.

Flags used to classify the first character in a token

Flags used to classify subsequent characters in a token

Map of utf-8 leading bytes to their class

Array of flags for different leading utf-8 sequences

The current buffer being read from. Encoded as UTF-8 with a null terminator.

Current offset within the buffer

The current token

Constructor

The raw byte stream to read from, encoded as UTF-8

Constructor

The text to read from

Copy constructor

Token reader to copy from

Gets a null terminated byte array from the given string

String to convert into bytes Array of bytes

Tokenize an input string

Text to tokenize List of tokens parsed from the text

Current line number (one-based)

Line number at the end of this token (one-based)

Returns the current token

Untyped implementation of Current for IEnumerator.

Override of IEnumerator.Dispose. Not required.

Move to the next token

True if the reader could move to the next token, false otherwise

Move to the next token, parsing a single literal token string until the end of the line (in the form used by error directives)

True if a token was parsed

Move to the next token, allowing include directives in triangle brackets in the style permitted by system include directives

True if a token was read

Creates a literal token

Type of token to create Flags for the token Offset of the literal within the source data stream Length of the literal New token for the literal

Scan ahead until we reach the next directive (a hash token after a newline). Assumes that the current line does not contain a directive.

True if we were able to find another token

Definition of IEnumerator.Reset(). Not supported.

Attempts to read a given character from the stream

Character to read True if the character was read (and the current position was updated)

Advances the given position past any horizontal whitespace or comments

Flags for the following token

Skip past a text literal (a quoted character literal or string literal)

The terminating character to look for, ignoring escape sequences

Skips over a numeric literal after the initial digit or dot/digit pair.

Static constructor. Initializes the lookup tables used by the lexer.

Class that stores info about aliased file.

CLion project file generator which is just the CMakefileGenerator and only here for UBT to match against

Creates a new instance of the class.

CMakefile project file generator implementation

Creates a new instance of the class.

Determines whether or not we should generate code completion data whenever possible.

true if we should generate code completion data; false otherwise.

Is this a project build?

This determines if engine files are included in the source lists. true if we should treat this as a project build; false otherwise.

The file extension for this project file.

The CMake helper file extension

The CMake file used to store the list of includes for the project.

The CMake file used to store the configuration files (INI) for the engine.

The CMake file used to store the configuration files (INI) for the project.

The CMake file used to store the additional build configuration files (CSharp) for the engine.

The CMake file used to store the additional configuration files (CSharp) for the project.

The CMake file used to store the additional shader files (usf/ush) for the engine.

The CMake file used to store the additional shader files (usf/ush) for the project.

The CMake file used to store the list of engine headers.

The CMake file used to store the list of engine headers.

The CMake file used to store the list of sources for the engine.

The CMake file used to store the list of sources for the project.

The CMake file used to store the list of definitions for the project.

Writes the primary project file (e.g. Visual Studio Solution file)

The UnrealBuildTool project The registered platform project generators True if successful Adds the include directory to the list, after converting it to relative to Unreal root

This will filter out numerous targets to speed up cmake processing

Whether to include iOS targets or not

Whether to include TVOS targets or not

Allocates a generator-specific project file object

Path to the project file The base directory for files within this project The newly allocated project file object

Constructor

KDevelop project file generator implementation

File extension for project files we'll be generating (e.g. ".vcxproj")

Write the primare $ProjectName.kdev4 project file, the one that should be opened when loading the project into KDevelop

File content. Name.

Write the Command Sub section for .kdev4/$ProjectName.kdev4 file

File content. Target name. Conf name. Build config index. Type.

Write the Command section for a .kdev4/$ProjectName.kdev4 file.

File content.

Adds the include directory to the list, after converting it to an absolute path to UnrealEngine root directory.

File content.

Splits the definition text into macro name and value (if any).

Definition text Out: The definition name Out: The definition value or null if it has none Pair representing macro name and value.

Write the defines section to the .kdev4/$ProjectName.kdev4 project file.

File content. Logger for output

Excludes list in one big ugly list.

File content. Simple Place to call all the Write*Section functions. ProjectFileGenerator interface ProjectFileGenerator interface

Allocates a generator-specific project file object

Path to the project file The base directory for files within this project The newly allocated project file object ProjectFileGenerator interface

Makefile project file generator implementation

True if intellisense data should be generated (takes a while longer) Now this is needed for project target generation. Default constructor True if we should include IntelliSense data in the generated project files when possible File extension for project files we'll be generating (e.g. ".vcxproj") ProjectFileGenerator interface ProjectFileGenerator interface

Allocates a generator-specific project file object

Path to the project file The base directory for files within this project The newly allocated project file object ProjectFileGenerator interface

Base class for platform-specific project generators

Constructor

Command line arguments passed to the project generator Logger for output

Register the platform with the UEPlatformProjectGenerator class

Checks the local VS install directories to see if the platform is supported.

The ProjectFileSettings that contains the project platform/configuration/etc info being built bool true if native VisualStudio support (or custom VSI) is available

Return the VisualStudio platform name for this build platform

The ProjectFileSettings that contains the project platform/configuration/etc info being built string The name of the platform that VisualStudio recognizes

Return whether we need a distinct platform name - for cases where there are two targets of the same VS solution platform

The ProjectFileSettings that contains the project platform/configuration/etc info being built bool

Return project configuration settings that must be included before the default props file for all configurations

The UnrealTargetPlatform being built String builder for the project file string The custom configuration section for the project file; Empty string if it doesn't require one

Return project configuration settings that must be included before the default props file

The UnrealTargetPlatform being built The UnrealTargetConfiguration being built String builder for the project file string The custom configuration section for the project file; Empty string if it doesn't require one

Return the platform toolset string to write into the project configuration

The ProjectFileSettings that contains the project platform/configuration/etc info being built String builder for the project file string The custom configuration section for the project file; Empty string if it doesn't require one

Return any custom property group lines

The ProjectFileSettings that contains the project platform/configuration/etc info being built String builder for the project file string The custom property import lines for the project file; Empty string if it doesn't require one

Return any custom property group lines

The ProjectFileSettings that contains the project platform/configuration/etc info being built string The platform configuration type. Defaults to "Makefile" unless overridden

Return any custom paths for VisualStudio this platform requires This include ReferencePath, LibraryPath, LibraryWPath, IncludePath and ExecutablePath.

The ProjectFileSettings that contains the project platform/configuration/etc info being built The type of target (game or program) Path to the .target.cs file String builder for the project file The custom path lines for the project file; Empty string if it doesn't require one

Return any custom property settings. These will be included in the ImportGroup section

The ProjectFileSettings that contains the project platform/configuration/etc info being built String builder for the project file string The custom property import lines for the project file; Empty string if it doesn't require one

Return any custom property settings. These will be included right after Global properties to make values available to all other imports.

The ProjectFileSettings that contains the project platform/configuration/etc info being built String builder for the project file string The custom property import lines for the project file; Empty string if it doesn't require one

Return any custom target overrides. These will be included last in the project file so they have the opportunity to override any existing settings.

The ProjectFileSettings that contains the project platform/configuration/etc info being built String builder for the project file string The custom property import lines for the project file; Empty string if it doesn't require one

Return any custom layout directory sections

The ProjectFileSettings that contains the project platform/configuration/etc info being built The type of target (game or program) string The custom property import lines for the project file; Empty string if it doesn't require one

Get the output manifest section, if required

The ProjectFileSettings that contains the project platform/configuration/etc info being built The type of the target being built Path to the .target.cs file Path to the project file The output manifest section for the project file; Empty string if it doesn't require one

Get whether this platform deploys

bool true if the 'Deploy' option should be enabled

Additional configuration related to Visual Studio user file (.vcxproj.user).

Patch existing .vcxproj.user file based on the new file content and corresponding patching settings, by doing the following: - Go over every <PropertyGroup> in the new document. - Finds <PropertyGroup> in the current document with matching "Condition" attribute. - If no property group is found, appends property group from new document to the end of current document. - Otherwise, saves values of properties configured with bPreserveExistingValue == true. - Removes all properties flagged for patching from current document property group. - Adds all properties required for patching from new document property group as declared in new document order. This makes possible to override some properties crucial for UE features while keeping rest of user configuration intact. Otherwise, if .vcxproj.user doesn't exist, patching do nothing and instead creates a new file based on new file content.

Name of the property to patch. If true, the value of the property will be taken from existing user file, but relative order will be taken from newly generated file.

Get the text to insert into the user file for the given platform/configuration/target

Configuration for user file creation/patching/etc. The ProjectFileSettings that contains the project platform/configuration/etc info being built The condition string The target rules The target rules path The project file path Output path for NMake The name of the project Path to foreign .uproject file, if any The string to append to the user file

For Additional Project Property files that need to be written out. This is currently used only on Android.

For additional Project files (ex. *PROJECTNAME*-AndroidRun.androidproj.user) that needs to be written out. This is currently used only on Android.

Project file this will be related to

For additional Project files (ex. *PROJECTNAME*-AndroidRun.androidproj) that needs to be written out. This is currently used only on Android.

Project file this will be related to Project file written out, Solution folder it should be put in

Gets the text to insert into the UnrealVS configuration file

Gets the text to insert into the Project files as additional build arguments for given platform/configuration

The ProjectFileSettings that contains the project platform/configuration/etc info being built

Indicates whether this generator will be emitting additional build targets. Functionally, it's fine to return true and not return any additional text in GetVisualStudioTargetsString, but doing so may incur additional cost of preparing data for generation.

The platform being added True if Targets will be generate, false otherwise. If true is returned, GetVisualStudioTargetsString will be called next.

Get the text to insert into the Project files as additional build targets for the given platform.

The platform being added List of build configurations for the platform String builder for the project file

Get include paths to system headers (STL, SDK, ...) needed for coding assistance features in IDE

Target for which include paths shall be returned The list of include paths

Stores all the registered platform project generators

Returns the list of platforms that have been registered in this collection

Registered platforms

Register the given platforms UEPlatformProjectGenerator instance

The UnrealTargetPlatform to register with The UEPlatformProjectGenerator instance to use for the InPlatform Logger for output

Retrieve the UEPlatformProjectGenerator instance for the given TargetPlatform

The UnrealTargetPlatform being built If true, do not throw an exception and return null UEPlatformProjectGenerator The instance of the project generator

Allow various platform project generators to generate stub projects if required

Allow various platform project generators to generate any special project properties if required

Data common to all generated Project entries

Platforms supported by the target Extra supported build configurations. Normally the target rules determines these, but for synthetic targets we'll add them here. Extra supported build platforms. Normally the target rules determines these, but for synthetic targets we'll add them here. If true, forces Development configuration regardless of which configuration is set as the Solution Configuration Whether the project requires 'Deploy' option set (VC projects) Optional target rules for this target. If the target came from a *.Target.cs file on disk, then it will have one of these. For targets that are synthetic (like UnrealBuildTool or other manually added project files) we won't have a rules object for those. Never set for an untargeted project

Path to the .uproject file on disk Never set for an untargeted project.

Description of a project build configuration provided during project generation by ProjectFile.

Name of the build configuration as displayed in the IDE e.g. Debug_Client.

Build command associated with this build configuration (as generated by classes derived from ProjectFile).

Represents a single source file (or other type of file) in a project

Constructor

Path to the source file on disk The directory on this the path within the project will be relative to

File path to file on disk

Optional directory that overrides where files in this project are relative to when displayed in the IDE. If null, will default to the project's BaseFolder.

Define ToString() so the debugger can show the name in watch windows

Constructs a new project file object

The path to the project file, relative to the primary project file The base directory for files within this project Project file path

The base directory for files within this project

Returns true if this is a generated project (as opposed to an imported project) Returns true if this is a "stub" project. Stub projects function as simple containers for source files and are never actually "built" by the primary project. Stub projects are always "generated" projects. Returns true if this is a foreign project, and requires UBT to be passed the path to the .uproject file on the command line. Returns true if this is a content only project, and will be re-using the engine targets Returns true if this is a project without source code, but some build setting requires it to be compiled as code, which will make a unique executable, instead of using UnrealGame, etc @note: Currently unused by any generator, but a future generator may make use of it Whether this project should be built for all solution targets Whether this project should be built by default. Can still be built from the IDE through the context menu.

C++ version which is used in this project.

Information for IntelliSense: whether coroutines are enabled

All of the targets in this project. All non-stub projects must have at least one target.

Adds a list of files to this project, ignoring dupes

Files to add The directory the path within the project will be relative to

Set of all files that have been added

Aliased (i.e. files is custom filter tree) in this project

Adds aliased file to the project.

Aliased file.

Adds a file to this project, ignoring dupes

Path to the file on disk The directory the path within the project will be relative to

Splits the definition text into macro name and value (if any).

Definition text Out: The definition name Out: The definition value or null if it has none Pair representing macro name and value.

Adds information about a module to this project file

The module to add Compile environment for this module

Adds all of the specified preprocessor definitions to this VCProject's list of preprocessor definitions for all modules in the project

List of preprocessor definitons to add

Adds all of the specified include paths to this VCProject's list of include paths for all modules in the project

The collection to add to List of include paths to add

Sets highest C++ version which is used in this project

Version

Sets whether coroutines should be enabled or not

Should enable them or not

Add the given project to the DepondsOn project list.

The project this project is dependent on

Writes a project file to disk

The platforms to write the project files for The configurations to add to the project files The registered platform project generators Logger for output True on success

If found writes a debug project file to disk

The platforms to write the project files for The configurations to add to the project files The registered platform project generators Logger for output List of project files written

Allocates a generator-specific source file object

Path to the source file on disk Optional sub-folder to put the file in. If empty, this will be determined automatically from the file's path relative to the project file The newly allocated source file object

Takes the given path and tries to rebase it relative to the project or solution directory variables.

Takes the given path and tries to rebase it relative to the project.

Takes the given path, normalizes it, and quotes it if necessary.

Visualizer for the debugger

Map of file paths to files in the project.

Files in this project

Collection of include paths

Build environment for a particular module

Merged list of include paths for the project

Merged list of include paths for the project

Map of base directory to user include paths

Legacy accessor for user search paths

Legacy accessor for system include paths

List of preprocessor definitions for the project

Set of unique preprocessor definitions

Projects that this project is dependent on

Represents a folder within the primary project (e.g. Visual Studio solution)

Constructor

Project file generator that owns this object Name for this folder Name of this folder

Adds a new sub-folder to this folder

Name of the new folder The newly-added folder

Recursively searches for the specified project and returns the folder that it lives in, or null if not found

The project file to look for The found folder that the project is in, or null Owner project generator Sub-folders Child projects Files in this folder. These are files that aren't part of any project, but display in the IDE under the project folder and can be browsed/opened by the user easily in the user interface

The type of project files to generate

Static class containing

Default list of project file formats to generate.

Parses a list of project file formats from a string

Sequence of project file formats

Base class for all project file generators

Global static that enables generation of project files. Doesn't actually compile anything. This is enabled only via UnrealBuildTool command-line.

Current ProjectFileGenerator that is in the middle of generating project files. Set just before GenerateProjectFiles() is called.

True if we're generating lightweight project files for a single game only, excluding most engine code, documentation, etc.

True if we're generating temporary solution/workspace that we want to put under Intermediate/ProjectFiles along with the projects to not dirty up the root dir

True will override any extra settings files like .vcxproj.user

Optional list of platforms to generate projects for

Whether to append the list of platform names after the solution

When bGeneratingGameProjectFiles=true, this is the game name we're generating projects for

Whether we should include configurations for "Test" and "Shipping" in generated projects. Pass "-NoShippingConfigs" to disable this.

Whether we should include configurations for "Debug" and "DebugGame" in generated projects. Pass "-NoDebugConfigs" to disable this.

Whether we should include configurations for "Development" in generated projects. Pass "-NoDevelopmentConfigs" to disable this.

True if intellisense data should be generated (takes a while longer).

True if visual studio project should be generated in linux mode.

True if we should include documentation in the generated projects.

True if all documentation languages should be included in generated projects, otherwise only INT files will be included.

True if build targets should pass the -useprecompiled argument.

True if we should include engine source in the generated solution.

True if shader source files should be included in generated projects.

True if build system files should be included.

True if we should include config (.ini) files in the generated project.

True if we should include localization files in the generated project.

True if we should include template files in the generated project.

True if we should include program projects in the generated solution.

Whether to include C++ targets

True if we should include csharp program projects in the generated solution. Pass "-DotNet" to enable this.

Whether to include temporary targets generated by UAT to support content only projects with non-default settings.

True if we should reflect "Source" sub-directories on disk in the primary project as project directories. This (arguably) adds some visual clutter to the primary project but it is truer to the on-disk file organization.

Names of platforms to include in the generated project files

Names of configurations to include in the generated project files. See UnrealTargetConfiguration for valid entries

If set, strip out other found Target.cs files

If true, this generator wants to have a project for each target type (UnrealGame, UnrealEditor, etc) and has only the straight configs (Debug, Development)

If true, this generator will add modules to multiple suitable projects (i.e. QAGame.Build.cs will be added to both QAGame and QAGameEditor), only makes sense when bMakeProjectPerTarget is true

If true, the project generator will allow conetnt-only projects for games with no targets, when generating for a single game target with -game

Relative path to the directory where the primary project file will be saved to

Name of the UE engine project that contains all of the engine code, config files and other files

Name of the UE engine project that contains all of the engine code, config files and other files

Name of the UE engine project that contains all of the engine code, config files and other files

When ProjectsAreIntermediate is true, this is the directory to store generated project files @todo projectfiles: Ideally, projects for game modules/targets would be created in the game's Intermediate folder!

Global static new line string used by ProjectFileGenerator to generate project files.

If true, we'll parse subdirectories of third-party projects to locate source and header files to include in the generated projects. This can make the generated projects quite a bit bigger, but makes it easier to open files directly from the IDE.

Name of the primary project file -- for example, the base file name for the Visual Studio solution file, or the Xcode project file on Mac.

If true, sets the primary project name according to the name of the folder it is in.

Maps all module files that were included in generated project files, to actual project file objects.

Maps all module files that were included in generated project files, to actual project file objects.

If generating project files for a single project, the path to its .uproject file.

File extension for project files we'll be generating (e.g. ".vcxproj")

True if we should include IntelliSense data in the generated project files when possible

True if this project generator requires a compile environment for Intellisense data.

Platforms we should generate IntelliSense data for, default is only build host platform.

Allows each project generator to indicate whether target rules should be used to explicitly enable or disable plugins. Default is false - since usually not needed for project generation unless project files indicate whether referenced plugins should be built or not.

Default constructor.

The project file passed in on the command line

Adds all rules project files to the solution.

Adds all the DotNet folder to the solution.

Creates a .props file next to each project which specifies the path to the engine directory

The properties file path

Finds all csproj within Engine/Source/Programs, and add them if their .uprogram file exists.

Finds the game projects that we're generating project files for

List of project files

Gets the user's preferred IDE from their editor settings

Project file being built Preferred format for the project being built True if a preferred IDE was set, false otherwise

Generates a Visual Studio solution file and Visual C++ project files for all known engine and game targets. Does not actually build anything.

The registered platform project generators Command-line arguments If true, write out target data for the editor Logger for output

Adds detected UBT configuration files (BuildConfiguration.xml) to engine project.

Engine project to add files to.

Clean project files

The primary project directory The name of the primary project The intermediate path of project files Logger for output

Configures project generator based on command-line options

Arguments passed into the program True if all platforms should be included Logger for output

Adds all game project files, including target projects and config files

Adds all engine localization text files to the specified project Adds all engine template text files to the specified project Adds all engine config files to the specified project Adds all engine extras files to the specified project Adds additional files from the platform extensions folder Adds UnrealHeaderTool config files to the specified project

Finds all module files (filtering by platform)

Filtered list of module files

List of non-redistributable folders

Checks if a module is in a non-redistributable folder

Finds all target files (filtering by platform)

Filtered list of target files

Returns a list of all sub-targets that are specialized for a given platform.

List of target files to find sub-targets for List of sub-targets in a flat list List of sub-targets bucketed by their parent target

Recursively collapses all sub-folders that are redundant. Should only be called after we're done adding files and projects to the primary project.

The folder whose sub-folders we should potentially collapse into

Validate the specified Folder. Default implementation requires for project file names to be unique!

Folder. Parent primary project folder path.

Adds UnrealBuildTool to the primary project

Adds a C# project to the primary project

Name of project file to add Logger for output ProjectFile if the operation was successful, otherwise null.

Adds all of the config files for program targets to their project files

Generates data for IntelliSense (compile definitions, include paths)

Incoming command-line arguments to UBT Targets to build for intellisense Logger for output Whether the process was successful or not

Selects which platforms and build configurations we want in the project file

True if we should include ALL platforms that are supported on this machine. Otherwise, only desktop platforms will be included. Output string for supported platforms, returned as comma-separated values.

Is this a valid platform. Used primarily for Installed vs non-Installed builds.

true if valid, false if not

Find the game which contains a given input file.

All game folders Full path of the file to search for

Finds all modules and code files, given a list of games to process

All game folders Map of generated Project File to the .uproject file for a given game. All program projects All mod projects List of *.Build.cs files for all engine programs and games True to gather source code from third party projects too Logger for output

Creates project entries for all known targets (*.Target.cs files)

The registered platform project generators All game folders All the target files to add The commandline arguments used The engine projects we created Map of game folder name to all of the game projects we created Map of generated Project File to the .uproject file for a given game. Map of program names to all of the program projects we created Map of RuleAssemblies to their base folders Logger for output

Adds separate project files for all mods

List of game project files Receives the list of mod projects on success

Gets the location for a project file

The base name for the project file Full path to the project file Adds shader source code to the specified project Adds engine build infrastructure files to the specified project Adds engine documentation to the specified project

Adds a new project file and returns an object that represents that project file (or if the project file is already known, returns that instead.)

Full path to the project file Base directory for files in this project True if this project should be included in the set of generated projects. Only matters when actually generating project files. True if we already had this project file Object that represents this project file in Unreal Build Tool

Allocates a generator-specific project file object

Path to the project file The base directory for files within this project The newly allocated project file object

Returns a list of all the known project files

Project file list

Writes the project files to disk

True if successful

Writes the primary project file (e.g. Visual Studio Solution file)

The UnrealBuildTool project The platform project file generators True if successful

Writes any additional solution-wide debug files (e.g. UnrealVS hints)

The platform project generators Intermediate project files folder Logger for output

Allows the generator to XXXXXXXxXXXXXXXxXXXXXXXxXXXXXXXx

Writes the specified string content to a file. Before writing to the file, it loads the existing file (if present) to see if the contents have changed

File to write File content True if the file was saved, or if it didn't need to be overwritten because the content was unchanged

Adds the given project to the OtherProjects list

The project to add True if successful

Retrieves the user-set default target name for a given target type. This is used for cases where a target type can have multiple target names but only one is used for default builds.

The project directory to find the configuration files in The target type to find a default value for. The name of the default target, or null The default project to be built for the solution. The project for UnrealBuildTool. Note that when generating project files for installed builds, we won't have an UnrealBuildTool project at all. List of platforms that we'll support in the project files List of build configurations that we'll support in the project files Map of project file names to their project files. This includes every single project file in memory or otherwise that we know about so far. Note that when generating project files, this map may even include project files that we won't be including in the generated projects. List of project files that we'll be generating List of other project files that we want to include in a generated solution file, even though we aren't generating them ourselves. Note that these may *not* always be C++ project files (e.g. C#) List of top-level folders in the primary project file

Helper class used for comparing the existing and generated project files.

Used by CompareOrdinalIgnoreWhitespaceAndCase to determine if a whitespace can be ignored.

Whitespace character. true if the character can be ignored, false otherwise.

Compares two project files ignoring whitespaces, case and GUIDs.

Compares two specified String objects by evaluating the numeric values of the corresponding Char objects in each string. Only space and tabulation characters are ignored. Ignores leading whitespaces at the beginning of each line and differences in whitespace sequences between matching non-whitespace sub-strings. The first string to compare. The second string to compare. An integer that indicates the lexical relationship between the two comparands.

Compares two project files ignoring case and GUIDs.

The first string to compare. The second string to compare. An integer that indicates the lexical relationship between the two comparands.

Compares two project files ignoring case and GUIDs.

The first string to compare. The second string to compare. True if whitsapces should be ignored. An integer that indicates the lexical relationship between the two comparands.

A single targeted (with a TargetFilePath) project within a project. A project may have any number of targets within it. in themselves that the project wraps up.

The target rules file path on disk, if we have one The project file path on disk Delegate for creating a rules instance for a given platform/configuration

QMakefile project file generator implementation

Default constructor File extension for project files we'll be generating (e.g. ".vcxproj")

Splits the definition text into macro name and value (if any).

Definition text Out: The definition name Out: The definition value or null if it has none Pair representing macro name and value. Adds the include directory to the list, after converting it to relative to Unreal root ProjectFileGenerator interface ProjectFileGenerator interface

Allocates a generator-specific project file object

Path to the project file The base directory for files within this project The newly allocated project file object ProjectFileGenerator interface

Write project file info in JSON file. For every combination of UnrealTargetPlatform, UnrealTargetConfiguration and TargetType will be generated separate JSON file. Project file will be stored: For UE: {UnrealRoot}/Engine/Intermediate/ProjectFiles/.Rider/{Platform}/{Configuration}/{TargetType}/{ProjectName}.json For game: {GameRoot}/Intermediate/ProjectFiles/.Rider/{Platform}/{Configuration}/{TargetType}/{ProjectName}.json

* TargetType.Editor will be generated for current platform only and will ignore UnrealTargetConfiguration.Test and UnrealTargetConfiguration.Shipping configurations * TargetType.Program will be generated for current platform only and UnrealTargetConfiguration.Development configuration only

Write a Target to a JSON writer. Is array is empty, don't write anything

Writer for the array data Logger for output

Write a Module to a JSON writer. If array is empty, don't write anything

Writer for the array data

Write an array of Modules to a JSON writer. If array is empty, don't write anything

Writer for the array data Name of the array property Sequence of Modules to write. May be null.

Write an array of strings to a JSON writer. Ifl array is empty, don't write anything

Writer for the array data Name of the array property Sequence of strings to write. May be null.

Write uplugin content to a JSON writer

Uplugin description JSON writer

Setup plugins for Target and write plugins to JSON writer. Don't write anything if there are no plugins

Write information about this binary to a JSON file

Writer for this binary's data

Write C++ toolchain information to JSON writer

List of deprecated platforms. Don't generate project model for these platforms unless they are specified in "Platforms" console arguments.

When specified only primary project file (root.json) will be generated. Normally project files for specific configurations are generated together with primary project file.

Platforms to generate project files for

Target types to generate project files for

Target configurations to generate project files for

Projects to generate project files for

Should format JSON files in human readable form, or use packed one without indents

Includes all files in the generated workspace.

Whether VS Code project generation should include debug configurations to allow attaching to already running processes

Whether VS Code project generation should include debug configurations to allow core dump debugging

Do not create compile commands json files with compiler arguments for each file; works better with VS Code extension using UBT server mode.

Create a workspace file for use with VS Code extension that communicates directly with UBT.

Visual Studio for Mac project file generator implementation

Default constructor

The single project to generate project files for, or null Additional command line arguments True if we should include IntelliSense data in the generated project files when possible

Writes the project files to disk

True if successful

Collection of output files for this project

Collect available configurations for the project storing it at availableConfigurations dictionary.

Keys for the dictionary are available project names.

Write project file info in JSON file. For every combination of UnrealTargetPlatform, UnrealTargetConfiguration and TargetType will be generated separate JSON file.

* TargetType.Editor will be generated for current platform only and will ignore UnrealTargetConfiguration.Test and UnrealTargetConfiguration.Shipping configurations * TargetType.Program will be generated for current platform only and UnrealTargetConfiguration.Development configuration only

Filter configurations based on what is supported by the project.

Write a Target to a JSON writer. Is array is empty, don't write anything

Logger for output Project file format.

Write a Module to a JSON writer. If array is empty, don't write anything

List of deprecated platforms. Don't generate project model for these platforms unless they are specified in "Platforms" console arguments.

Platforms to generate project files for

Target types to generate project files for

Target configurations to generate project files for

Projects to generate project files for

Should format JSON files in human readable form, or use packed one without indents

Specifies the context for building an MSBuild project

Name of the configuration

Name of the platform

Whether this context should be built by default

Whether this context should be deployed by default

Constructor

Name of this configuration Name of this platform

The name of this context

Serializes this context to a string for debugging

Name of this context

Represents an arbitrary MSBuild project

The project file version string The build configuration name to use for stub project configurations. These are projects whose purpose is to make it easier for developers to find source files and to provide IntelliSense data for the module to Visual Studio The name of the Visual C++ platform to use for stub project configurations NOTE: We always use Win32 for the stub project's platform, since that is guaranteed to be supported by Visual Studio

The Guid representing the project type e.g. C# or C++

Constructs a new project file object

The path to the project file on disk The base directory for files within this project

Attempts to load the project's GUID from an existing project file on disk

Get the project context for the given solution context

The solution target type The solution configuration The solution platform Set of platform project generators The target architecture Logger for output Project context matching the given solution context

Checks to see if the specified solution platform and configuration is able to map to this project

The target that we're checking for a valid platform/config combination Platform Configuration Logger for output True if this is a valid combination for this project, otherwise false

Escapes characters in a filename so they can be stored in an XML attribute

The filename to escape The escaped filename

GUID for this Visual C++ project file

This is the platform name that Visual Studio is always guaranteed to support. We'll use this as a platform for any project configurations where our actual platform is not supported by the installed version of Visual Studio (e.g, "iOS")

Constructs a new project file object

The path to the project file on disk The base directory for files within this project Visual C++ project file version Whether to add the -UsePrecompiled argumemnt when building targets Whether to add roll the target type into the config (ie "Development Editor") Optional arguments to pass to UBT when building Other settings

Gets highest C++ version which is used in this project

C++ standard version

Gets compiler switch for specifying in AdditionalOptions in .vcxproj file for specific C++ version

Gets compiler switch for specifying in AdditionalOptions in .vcxproj file for coroutines support

If found writes a debug project file to disk

True on success

Append a list of include paths to a property list

String builder for the property value Collection of include paths Set of paths to ignore Implements Project interface

Write additional Target elements if needed by per-platform generators.

Returns the VCFileType string based on the VCFileType enum.

Name of the element in MSBuild project file for this file type

Returns the VCFileType enum value based on the file path.

The path of the file to return type for. VCFileType enum value for this file.

A Visual C# project.

This is the GUID that Visual Studio uses to identify a C# project file in the solution

Platforms that this project supports

Configurations that this project supports

Constructs a new project file object

The path to the project file on disk Logger for output The base directory for files within this project - if not specified, InitFilePath.Directory will be used

Extract information from the csproj file based on the supplied configuration

Determine if this project is a .NET Core project

Gets a property from the project

Basic csproj file support. Generates C# library project with one build config.

Not used. Not Used. Set of platform project generators true if the opration was successful, false otherwise Cache of parsed info about this project

The version of Visual Studio to generate project files for.

Puts the most common include paths in the IncludePath property in the MSBuild project. This significantly reduces Visual Studio memory usage (measured 1.1GB -> 500mb), but seems to be causing issues with Visual Assist. Value here specifies maximum length of the include path list in KB.

Semi-colon separated list of paths that should not be added to the projects include paths. Useful for omitting third-party headers (e.g ThirdParty/WebRTC) from intellisense suggestions and reducing memory footprints.

Semi-colon separated list of paths that should not be added to the projects. Useful for omitting third-party files (e.g ThirdParty/WebRTC) from intellisense suggestions and reducing memory footprints.

Whether to write a solution option (suo) file for the sln.

Whether to write a .vsconfig file next to the sln to suggest components to install.

Forces UBT to be built in debug configuration, regardless of the solution configuration

Whether to add the -FastPDB option to build command lines by default.

Whether to generate per-file intellisense data.

Whether to include a dependency on ShaderCompileWorker when generating project files for the editor.

Whether to include a dependency on LiveCodingConsole when building targets that support live coding.

Whether to generate a project file for each individual target, and not include e.g. Editor/Client/Server in the Configuration.

Visual C++ project file generator implementation

The settings object

Set to true to enable a project for each target, and do not put the target type into the configuration

Override for the build tool to use in generated projects. If the compiler version is specified on the command line, we use the same argument on the command line for generated projects.

Default constructor

The single project to generate project files for, or null Override the project file format to use Additional command line arguments File extension for project files we'll be generating (e.g. ".vcxproj")

Allocates a generator-specific project file object

Path to the project file The base directory for files within this project The newly allocated project file object "4.0", "12.0", or "14.0", etc... for instance: v110

Returns a list of architectures to generate unique VS platforms for.

Selects which platforms and build configurations we want in the project file

True if we should include ALL platforms that are supported on this machine. Otherwise, only desktop platforms will be included. Output string for supported platforms, returned as comma-separated values.

Used to sort VC solution config names along with the config and platform values

Visual Studio solution configuration name for this config+platform

Configuration name

Platform name

The target type

The target architecture

Composes a string to use for the Visual Studio solution configuration, given a build configuration and target rules configuration name

The build configuration The type of target being built True if we are making one project per target type, instead of rolling them into the configs The generated solution configuration name

Writes the project files to disk

True if successful

Takes a string and "cleans it up" to make it parsable by the Visual Studio source control provider's file format

String to clean up The cleaned up string

Generates an Xcode project that acts as a native wrapper for an Unreal Project built as a framework.

Recursively copies all of the files and directories that are inside into .

The directory whose contents should be copied. The directory into which the files should be copied.

An enumeration specifying the type of a filesystem entry, either directory, file, or something else.

Gets the type of filesystem entry pointed to by .

The type of filesystem entry pointed to by . The path to a filesystem entry.

Recursively renames all files and directories that contain in their name by replacing with .

Root directory. Old value. New value.

Opens each file in and replaces all occurrences of with .

The directory in which all files should be subject to replacements. Only replace text in files that match this pattern. Default is all files. The value that should be replaced in all files. The replacement value.

Modifies the Xcode project file to change a few build settings.

The root directory of the template project that was created. The name of the framework that this project is wrapping. The Bundle ID to give to the wrapper project. The path to the directory containing the framework to be wrapped. The path to the root Unreal Engine directory. The path to the 'cookeddata' folder that accompanies the framework.

Removes the readonly attribute from all files in a directory file while retaining all other attributes, thus making them writeable.

The path to the directory that will be make writeable.

Changes the value of a setting in a project file.

The project file contents with the setting replaced. The contents of a settings file. The name of the setting to change. The new value for the setting.

There are some autogenerated directories that could have accidentally made it into the template. This method tries to delete those directories as an extra precaution.

The directory which should be recursively searched for unwanted directories.

Generates an Xcode project that acts as a native wrapper around an Unreal Project built as a framework. Wrapper projects are generated by copying a template xcode project from the Build Resources directory, deleting any user-specific or build files, renaming files and folders to match the framework, setting specific settings in the project to accommodate the framework, and replacing text in all the files to match the framework.

The directory in which to place the framework. The framework will be placed in 'outputDirectory/frameworkName/'. The name of the project. If blueprint-only, use the actual name of the project, not just UnrealGame. The name of the framework that this project is wrapping. The Bundle ID to give to the wrapper project. The path to the directory containing the framework to be wrapped. The path to the root Unreal Engine directory. The path to the 'cookeddata' folder that accompanies the framework.

Used to mark the project for distribution (some platforms require this)

Override for bundle identifier

Override AppName

Architectures supported for iOS

UBT logger object

Abstract function the individual node classes must override to write out the node to the project file

Walks the references of the given node to find all nodes of the given type.

Parent class of the nodes to return Root node to start with Set of matching nodes

THhis will walk the node reference tree and call WRite on each node to add all needed nodes to the xcode poject file

Let subclasses add extra properties into this target section

Write some scripts to do some fixup with how UBT links files. There is currently a difference between Mac and IOS/TVOS: All: - The staged files gets pulled into the .app for a self-contained app, created at Xcode build time, unless an envvar is set that tells this script to skip the copy. This allows UAT to potentially skip copying staged files before we stage ("BuildCookRun -build -cook -stage -package" can skip the copying until the -package step). Also we don't copy anything if this is the engine, no-project, build, and an Mac: - UBT will link executable next to .app - We will copy it into .app here, similar to iOS - However, during Archiving, the .app is created in a intermediate location, so then here we copy from Binaries/Mac to the intermediate location - Trying to have UBT link directly to the intermeidate location causes various issues, so we copy it like IOS does IOS/TVOS: - IOS will link to Binaries/IOS/Foo - During normal operation, here we copy from Binaries/IOS/Foo to Binaries/IOS/Foo.app/Foo - Note that IOS and Mac have different internal directory structures (which EXECUTABLE_PATH expresses) - When Archiving, we copy from Binaries/IOS/Foo to the intermediate location's .app All: - At this point, the executable is in the correct spot, and so CONFIGURATION_BUILD_DIR/EXECUTABLE_PATH points to it - So here we gneerate a dSYM from the executable, copying it to where Xcode wants it (DWARF_DSYM_FOLDER_PATH/DWARF_DSYM_FILE_NAME), and then we strip the executable in place

Constructs a new project file object

The path to the project file on disk The base directory for files within this project True for distribution builds Override option for bundle identifier

The PBXPRoject node, root of everything

Gathers the files and generates project sections

Allocates a generator-specific source file object

Path to the source file on disk Optional sub-folder to put the file in. If empty, this will be determined automatically from the file's path relative to the project file The newly allocated source file object

Generates bodies of all sections that contain a list of source files plus a dictionary of project navigator groups.

Implements Project interface

Info needed to make a file a member of specific group

Constructor

File Guid for use in Xcode project

File reference Guid for use in Xcode project

Represents a group of files shown in Xcode's project navigator as a folder

The project needs to point to the product group, so we expose the Guid here

Gets Xcode file type based on its extension

Returns true if Extension is a known extension for files containing source code

Returns true if Extension is a known extension for files containing resource data

Cache the folders excluded by Mac

Returns a project navigator group to which the file should belong based on its path. Creates a group tree if it doesn't exist yet.

Convert all paths to Apple/Unix format (with forward slashes)

The path to convert The normalized path

Returns the Mac architectures that should be configured for the provided target. If the target has a project we'll adhere to whether it's set as Intel/Universal/Apple unless the type is denied (pretty much just Editor) If the target has no project we'll support allow-listed targets for installed builds and all non-editor architectures for source builds. Not all programs are going to compile for Apple Silicon, but being able to build and fail is useful...

The target we're generatin forg Path to the project file, or null if the target has no project

Xcode project file generator implementation

Xcode makes a project per target, for modern to be able to pull in Cooked data

Mark for distribution builds

Override BundleID

Override AppName

Store the single game project (when using -game -project=...) to a place that XcodeProjectLegacy can easily retrieve it

Shared file that the project agnostic projects can point to to get content only projects working nicely in Xcode

A static copy of ProjectPlatforms from the base class

Should we generate only a run project (no build/index targets)

Platforms we should generate IntelliSense data for, Xcode projects should index for each Apple platform.

Make a random Guid string usable by Xcode (24 characters exactly)

File extension for project files we'll be generating (e.g. ".vcxproj")

Allocates a generator-specific project file object

Path to the project file The base directory for files within this project The newly allocated project file object

Represents a group of files shown in Xcode's project navigator as a folder

Constructs a new project file object

The path to the project file on disk The base directory for files within this project True for distribution builds Override option for bundle identifier

Temporary for developing this feature

Used to mark the project for distribution (some platforms require this)

Override for bundle identifier

Override AppName

Architectures supported for iOS

Gets Xcode file category based on its extension

Gets Xcode file type based on its extension

Returns true if Extension is a known extension for files containing source code

Returns a project navigator group to which the file should belong based on its path. Creates a group tree if it doesn't exist yet.

Convert all paths to Apple/Unix format (with forward slashes)

The path to convert The normalized path

Allocates a generator-specific source file object

Path to the source file on disk Optional sub-folder to put the file in. If empty, this will be determined automatically from the file's path relative to the project file The newly allocated source file object

Generates bodies of all sections that contain a list of source files plus a dictionary of project navigator groups.

Returns the Mac architectures that should be configured for the provided target. If the target has a project we'll adhere to whether it's set as Intel/Universal/Apple unless the type is denied (pretty much just Editor) If the target has no project we'll support allow-listed targets for installed builds and all non-editor architectures for source builds. Not all programs are going to compile for Apple Silicon, but being able to build and fail is useful...

Build config for the target we're generating Path to the project file, or null if the target has no project Implements Project interface

Storage provider which uses the filesystem

Cached copy of the current process id

Implements for writes to the backing storage

Represents a write transaction to the cache. Commit() should be called once the transaction is complete.

Attempts to open a file from the output cache

Digest of the item to retrieve Reader interface for the file

Opens a stream for writing into the cache. The digest

Gets the filename on disk to use for a particular digest

The digest to find a filename for Filename to use for the given digest

Interface for reads from content-addressible storage

Accessor for the read stream

Whether the reader contains any data

Interface for writes to content-addressible storage

Accessor for the write stream

Commits the written data to the cache

Interface for an artifact cache

Attempts to open a file from the output cache

Digest of the item to retrieve True if the item exists in the cache, false otherwise

Opens a stream for writing into the cache. The digest

Enumerates build action types.

Defines the action's support for artifacts

Cached artifacts aren't enabled

If set, the outputs should be cached but respect the flags below

Absolute file paths must be used when recording inputs and outputs

For actions that can't be cached, by setting this flag, the inputs for the action in question will be used as additional inputs for any action that references outputs of this action. For example, PCH files shouldn't be cached, but compiles that use the PCH should still be valid if consider the inputs used to create the PCH file.

The type of this action (for debugging purposes).

Artifact support for this step

Every file this action depends on. These files need to exist and be up to date in order for this action to even be considered

The files that this action produces after completing

Items that should be deleted before running this action

Root paths for this action (generally engine root project root, toolchain root, sdk root)

For C++ source files, specifies a dependency list file used to check changes to header files

Directory from which to execute the program to create produced items

The command to run to create produced items

Command-line parameters to pass to the program

Version of the command used for this action. This will be considered a dependency.

Optional friendly description of the type of command being performed, for example "Compile" or "Link". Displayed by some executors.

Human-readable description of this action that may be displayed as status while invoking the action. This is often the name of the file being compiled, or an executable file name being linked. Displayed by some executors.

True if this action is allowed to be run on a remote machine when a distributed build system is being used, such as XGE

True if this action is allowed to be run on a remote machine with SNDBS. Files with #import directives must be compiled locally. Also requires bCanExecuteRemotely = true.

True if this action is allowed to be run on a remote machine with XGE. Files with #import directives must be compiled locally. Also requires bCanExecuteRemotely = true.

True if this action can be executed by box

True if this action is using the GCC compiler. Some build systems may be able to optimize for this case.

Whether we should log this action, whether executed locally or remotely. This is useful for actions that take time but invoke tools without any console output.

Whether we should output log of this action, whether executed locally or remotely. This is useful for actions that spam logs to console output with non critical data

True if any libraries produced by this action should be considered 'import libraries'

Whether changes in the command line used to generate these produced items should invalidate the action

True if this action should be scheduled early. Some actions can take a long time (pch) and need to start very early If set to true it will propagate high priority to all its prerequisite tasks

Used to determine how much weight(CPU and Memory work) this action is.

A build action.

Preparation and Assembly (serialized)

The type of this action (for debugging purposes).

Artifact support for this step

Every file this action depends on. These files need to exist and be up to date in order for this action to even be considered

The files that this action produces after completing

Items that should be deleted before running this action

Root paths for this action (generally engine root project root, toolchain root, sdk root) Order needs to be mainted, so a list is used

For C++ source files, specifies a dependency list file used to check changes to header files

Directory from which to execute the program to create produced items

The command to run to create produced items

Command-line parameters to pass to the program

Version of the command used for this action. This will be considered a dependency.

Optional friendly description of the type of command being performed, for example "Compile" or "Link". Displayed by some executors.

Human-readable description of this action that may be displayed as status while invoking the action. This is often the name of the file being compiled, or an executable file name being linked. Displayed by some executors.

True if this action is allowed to be run on a remote machine when a distributed build system is being used, such as XGE

True if this action is allowed to be run on a remote machine with SNDBS. Files with #import directives must be compiled locally. Also requires bCanExecuteRemotely = true.

True if this action is allowed to be run on a remote machine with XGE. Files with #import directives must be compiled locally. Also requires bCanExecuteRemotely = true.

True if this action can be executed in box

True if this action is using the GCC compiler. Some build systems may be able to optimize for this case.

Whether we should log this action, whether executed locally or remotely. This is useful for actions that take time but invoke tools without any console output.

True if any libraries produced by this action should be considered 'import libraries'

ISerializable: Called when serialized to report additional properties that should be saved

Writes an action to a json file

The object to parse

Interface that is used when -SingleFile=xx is used on the cmd line to make specific files compile Actions that has this interface can be used to create real actions that can compile the specific files

The directory this action can create actions for

Creates an action for a specific file. It can return null if for example file extension is not handled

Extension methods for action classes

Writes an action to a json file

The action to write Map of action to unique id Writer to receive the output

Determine if this Action ignores output conficts.

The Action to check True if conflicts are ignored, else false.

Default serializer for instances

Information about an action queued to be executed

The inner action instance

A target that this action contributes to

Set of other actions that this action depends on. This set is built when the action graph is linked.

Total number of actions depending on this one.

Additional field used for sorting that can be used to control sorting of link actions from outside

True if this action should be scheduled early. Some actions can take a long time (pch) and need to start very early If set to 1 it will propagate high priority to all its prerequisite tasks. (Note it is an int to be able to do interlocked operations)

If set, will be output whenever the group differs to the last executed action. Set when executing multiple targets at once.

Constructor

The inner action instance

Increment the number of dependents, recursively

Set of visited actions Propagate high priority to this and prerequisite actions

Compares two actions based on total number of sort index, priority and dependent items, descending.

Action to compare Action to compare

Allow targets to override the expected amount of memory required for compiles, used to control the number of parallel action processes.

Execute the given actions

Actions to be executed Logger for output Cache used to read/write action outputs. True if the build succeeded, false otherwise

When completed, get a populated telemetry event for this executor

Post a telemetry event if enabled

Will verify that produced items exists on disk

Enum describing why an Action is in conflict with another Action

Links the actions together and sets up their dependencies

List of actions in the graph Logger for output Optional sorting of actions

Checks a set of actions for conflicts (ie. different actions producing the same output items)

The set of actions to check Logger for output

Finds conflicts between two actions, and prints them to the log

The first action The second action Logger for output True if no conflicts were found, false otherwise.

Adds the description of a merge error to an output message

The first action with the conflict The second action with the conflict Enum flags for which properties are in conflict Logger for output

Builds a list of actions that need to be executed to produce the specified output items.

Checks that there aren't any intermediate files longer than the max allowed path length

The build configuration List of actions in the graph

Selects an ActionExecutor

Executes a list of actions.

Sorts the action list for improved parallelism with local execution.

Checks for cycles in the action graph.

Determines the full set of actions that must be built to produce an item.

All the actions in the graph Set of output items to be built Set of prerequisite actions

Determines the full set of actions that must be built to produce an item.

The root action to scan Set of prerequisite actions

Determines whether an action is outdated based on the modification times for its prerequisite and produced items, without considering the full set of prerequisites. Writes to OutdatedActionDictionary iff the action is found to be outdated. Safe to run in parallel, but only with different RootActions.

- The action being considered. - true if outdated

Determines whether an action is outdated by examining the up-to-date state of all of its prerequisites, recursively. Not thread safe. Typically very fast.

- The action being considered. - Logger instance true if outdated

Determines if the dependency between two actions is only for an import library

The action to check The action that it depends on True if the only dependency between two actions is for an import library

Determines if the dependency on a between two actions is only for an import library

The action to check The dependency that is out of date True if the only dependency between two actions is for an import library

Test to see if the given file is a library file (or in the case of linux/mac, a dynamic library)

File to test True if the file is a library file

Builds a dictionary containing the actions from AllActions that are outdated by calling IsActionOutdated.

Deletes all the items produced by actions in the provided outdated action dictionary.

List of outdated actions Logger for output

Creates directories for all the items produced by actions in the provided outdated action dictionary.

Imports an action graph from a JSON file

The file to read from List of actions

Exports an action graph to a JSON file

The actions to write Output file to write the actions to

Interface for toolchain operations that produce output

Adds an action to this graph

Action to add

Creates a response file for use in the action graph

Location of the response file Contents of the file Allows the backend to write the file in a separate task. New file item

Creates a response file for use in the action graph, with a newline between each string in ContentLines

Location of the response file Contents of the file Allows the backend to write the file in a separate task. New file item

Adds a file which is in the non-unity working set

The file to add to the working set

Adds a file which is a candidate for being in the non-unity working set

The file to add to the working set

Adds a source directory. These folders are scanned recursively for C++ source files.

Base source directory

Adds the given source files as dependencies

Source directory containing files to build Contents of the directory

Adds a list of known header files

List of header files to track

Sets the output items which belong to a particular module

Name of the module Array of output items for this module

Adds a diagnostic message

Message to display

Implementation of IActionGraphBuilder which discards all unnecessary operations

Constructor

Implementation of IActionGraphBuilder which forwards calls to an underlying implementation, allowing derived classes to intercept certain calls

The inner graph builder

Constructor

Builder to pass all calls to

Extension methods for IActionGraphBuilder classes

Creates a new action to be built as part of this target

Graph to add the action to Type of action to create New action

Creates an action which copies a file from one location to another

The action graph The source file location The target file location File item for the output file

Creates an action which copies a file from one location to another

List of actions to be executed. Additional actions will be added to this list. The source file location The target file location File item for the output file

Creates an action which calls UBT recursively

The action graph Type of the action Arguments for the action New action instance

Creates a text file with the given contents. If the contents of the text file aren't changed, it won't write the new contents to the file to avoid causing an action to be considered outdated.

The action graph Path to the intermediate file to create Contents of the new file Allows the backend to write the file in a separate task. File item for the newly created file

Creates a text file with the given contents. If the contents of the text file aren't changed, it won't write the new contents to the file to avoid causing an action to be considered outdated.

The action graph Path to the intermediate file to create Contents of the new file Allows the backend to write the file in a separate task. File item for the newly created file

Caches include dependency information to speed up preprocessing on subsequent runs.

Version number to check

Path to store the cache data to.

The Attributes used to produce files, keyed by the absolute file paths.

Whether the dependency cache is dirty and needs to be saved.

Constructor

File to store this history in Logger for output

Attempts to load this action history from disk

Saves this action history to disk

Computes the case-invariant IoHash for a string

The text to hash IoHash of the string

Gets the producing attributes for the given file

The output file to look for Receives the Attributes used to produce this file True if Attributes have changed and is updated, false otherwise

Gets the location for the engine action history

Target name being built The platform being built Type of the target being built The target architecture(s) Path to the engine action history for this target

Gets the location of the project action history

Path to the project file Platform being built Name of the target being built The target architecture(s) Path to the project action history

Enumerates all the locations of action history files for the given target

Project file for the target being built Name of the target Platform being built The target type The target architecture(s) Dependency cache hierarchy for the given project

Information about actions producing artifacts under a particular directory

The base directory for this partition

Used to ensure exclusive access to the layers list

Map of filename to layer

Construct a new partition

The base directory for this partition

Attempt to update the producing command line for the given file

The file to update The new attributes Logger for output True if the attributes were updated, false otherwise

Get the path to the action history layer to use for the given file

Path to the file to use Path to the file

Attempts to match a substring of a path with the given fragment

Path to match against Offset of the substring to match Length of the substring to match The path fragment True if the substring matches

Saves the modified layers

A collection of ActionHistory layers

The lock object for this history

List of partitions

Constructor

Reads a cache from the given location, or creates it with the given settings

Base directory for files that this cache should store data for Reference to a dependency cache with the given settings

Gets the producing command line for the given file

The output file to look for Receives the Attributes used to produce this file Logger for output True if the output item exists

Saves all layers of this action history

Interface for a class that can serialize an action type

The action type

Read the action from an archive

Reader for the action New action

Writes an action to an archive

Writer for the archive The action to write

Generic base class for an action serializer

Read the action from an archive

Reader for the action New action

Writes an action to an archive

Writer for the archive The action to write

Helper methods for registering serializers and serializing actions

Map from type name to deserializing constructor

Map from serializer name to instance

Creates a map of type name to constructor

Read an action from the given archive

Reader to deserialize from New action

Reads a type name and find its registered constructor from an archive

Archive to read from New constructor info

Writes an action to the given archive

Writer to serialize the action to Action to serialize

Parser for ASN.1 BER formats (eg. iOS mobile provisions)

Base class for exceptions thrown by UBT

Constructor

The error message to display.

Constructor which wraps another exception

An inner exception to wrap The error message to display.

Constructor

Formatting string for the error message Arguments for the formatting string

Constructor which wraps another exception

The inner exception being wrapped Format for the message string Format arguments

Log BuildException with a provided ILogger

The ILogger to use to log this exception

Returns the string representing the exception. Our build exceptions do not show the callstack since they are used to report known error conditions.

Message for the exception

Implementation of that captures a full structured logging event.

The event object

Constructor

Event to construct from

Constructor which wraps another exception

The inner exception Event to construct from

Constructor which wraps another exception

Event id for the error Inner exception to wrap Structured logging format string Argument objects

Implementation of that will return a unique exit code.

The exit code associated with this exception

Constructor

The resulting exit code

Constructor

The resulting exit code Event to construct from

Constructor which wraps another exception

The resulting exit code The inner exception Event to construct from

Constructor

The resulting exit code Event id for the error Formatting string for the error message Arguments for the formatting string

Constructor

The resulting exit code Formatting string for the error message Arguments for the formatting string

Constructor which wraps another exception

The resulting exit code The inner exception being wrapped Format for the message string Format arguments

Constructor which wraps another exception

The resulting exit code Event id for the error Inner exception to wrap Structured logging format string Argument objects

Extension methods for build exceptions

Log Exception with a provided ILogger

The exception to log The ILogger to use to log this exception

Get the CompilationResult for a provided Exception

The exception to get the result for CompilationResult

The type of shell supported by this platform. Used to configure command line arguments.

The Bourne shell

Windows command interpreter

Host platform abstraction

Host platform singleton.

Gets the current host platform type.

Gets the path to the shell for this platform

The type of shell returned by the Shell parameter

The executable binary suffix for this platform

Class that holds information about a running process

Process ID

Name of the process

Filename of the process binary

Constructor

The process ID The process name The process filename

Constructor

Process to take information from

Format as a string for debugging

String containing process info

Gets all currently running processes.

Gets a process by name.

Name of the process to get information for.

Gets processes by name.

Name of the process to get information for.

Gets the filenames of all modules associated with a process

Process ID Filename of the binary associated with the process. An array of all module filenames associated with the process. Can be empty of the process is no longer running.

Determines if the UBT process is running through WINE

Sequence of project file formats

Determines the default project file formats for this platform

Sequence of project file formats

(needs confirmation) Currently returns incomplete process names in Process.GetProcesses() so we need to parse 'ps' output.

(needs confirmation) Currently returns incomplete list of modules for Process.Modules so we need to parse vmmap output.

(needs confirmation) Currently returns incomplete process names in Process.GetProcesses() so we need to use /proc (also, locks up during process traversal sometimes, trying to open /dev/snd/pcm*)

(needs confirmation) Currently returns incomplete list of modules for Process.Modules so we need to parse /proc/PID/maps. (also, locks up during process traversal sometimes, trying to open /dev/snd/pcm*)

Holds information about the current engine version

The major engine version (5 for UE5)

The minor engine version

The hotfix/patch version

The changelist that the engine is being built from

The changelist that the engine maintains compatibility with

Whether the changelist numbers are a licensee changelist

Whether the current build is a promoted build, that is, built strictly from a clean sync of the given changelist

Name of the current branch, with '/' characters escaped as '+'

The current build id. This will be generated automatically whenever engine binaries change if not set in the default Engine/Build/Build.version.

The build version string

Optional URL for a continuous integration job associated with this build version. (e.g. the job that build a set of binaries)

Returns the value which can be used as the compatible changelist. Requires that the regular changelist is also set, and defaults to the regular changelist if a specific compatible changelist is not set.

Try to read a version file from disk

Path to the version file The version information True if the version was read successfully, false otherwise

Get the default path to the build.version file on disk

Path to the Build.version file

Get the default path for a target's version file.

The output directory for the executable. For MacOS, this is the directory containing the app bundle. Name of the target being built Platform the target is being built for The configuration being built Architecture of the target being built Path to the target's version file

Parses a build version from a JsonObject

The object to read from The resulting version field True if the build version could be read, false otherwise

Exports this object as Json

The filename to write to

Exports this object as Json

The filename to write to Logger for output

Exports this object as Json

Writer for output text

Exports this object as Json

The json writer to receive the version settings True if the build version could be read, false otherwise

Read-only wrapper for a BuildVersion instance

The inner build version

Cached copy of the current build version

Constructor

The writable build version instance

Gets the current build version

Accessors for fields on the inner BuildVersion instance

Functions for parsing command line arguments

Stores information about the field to receive command line arguments

Prefix for the argument.

Field to receive values for this argument

The attribute containing this argument's info

Constructor

Parse the given list of arguments and apply them to the given object

List of arguments. Parsed arguments will be removed from this list when the function returns. Object to receive the parsed arguments. Fields in this object should be marked up with CommandLineArgumentAttribute's to indicate how they should be parsed.

Parse the given list of arguments and apply them to the given object

List of arguments. Parsed arguments will be removed from this list when the function returns. Object to receive the parsed arguments. Fields in this object should be marked up with CommandLineArgumentAttribute's to indicate how they should be parsed. Logger for output

Parse the given list of arguments, and remove any that are parsed successfully

List of arguments. Parsed arguments will be removed from this list when the function returns. Object to receive the parsed arguments. Fields in this object should be marked up with CommandLineArgumentAttribute's to indicate how they should be parsed. Logger for output

Checks that the list of arguments is empty. If not, throws an exception listing them.

List of remaining arguments Logger for output

Parses and assigns a value to a field

The parameter being parsed Argument text The target object to assign values to Maps assigned fields to the parameter that wrote to it. Used to detect duplicate and conflicting arguments. Logger for output

Attempts to parse the given string to a value

Type of the field to convert to The value text On success, contains the parsed object True if the text could be parsed, false otherwise

Caches config files and config file hierarchies

Delegate to add a value to an ICollection in a target object

The object containing the field to be modified The value to add

Caches information about a member with a [ConfigFile] attribute in a type

The attribute instance

For fields implementing ICollection, specifies the element type

For fields implementing ICollection, a callback to add an element type.

Constructor

Returns Reflection.MemberInfo describing the target class member.

Returns Reflection.Type of the target class member.

Returns the value setter of the target class member.

Returns the value getter of the target class member.

Caches information about a field with a [ConfigFile] attribute in a type

Reflection description of the field with the config attribute.

Constructor

Caches information about a property with a [ConfigFile] attribute in a type

Reflection description of the property with the config attribute.

Constructor

Allowed modification types allowed for default config files

Used for non-array types, this will replace a setting, or it will add a setting if it doesn't exist

Used to add an array entry to the end of any existing array entries, or will add to the end of the section

Stores information identifying a unique config hierarchy

The hierarchy type

The project directory to read from

Which platform-specific files to read

Custom config subdirectory to load

Custom override strings

A hotfix directory where modifications/additions to config files can be read from

If specified, this hierarchy will include plugins enabled for the given target type

Constructor

The hierarchy type The project directory to read from Which platform-specific files to read Custom config subdirectory to load Custom override strings A hotfix directory where modifications/additions to config files can be read from If specified, this hierarchy will unclude plugins enabled for the given target type

Test whether this key is equal to another object

The object to compare against True if the objects match, false otherwise

Returns a stable hash of this object

Hash value for this object

Cache of individual config files

Cache of config hierarchies by project

Cache of config fields by type

Attempts to read a config file (or retrieve it from the cache)

Location of the file to read On success, receives the parsed config file True if the file exists and was read, false otherwise

Reads a config hierarchy (or retrieve it from the cache)

The type of hierarchy to read The project directory to read the hierarchy for Which platform to read platform-specific config files for Optional override config directory to search, for support of multiple target types Optional list of command line arguments added to the existing command line arguments A hotfix directory where modifications/additions to config files can be read from If specified, this hierarchy will unclude plugins enabled for the given target type The requested config hierarchy

Reads a config hierarchy (or retrieve it from the cache)

The type of hierarchy to read The project directory to read the hierarchy for Which platform to read platform-specific config files for Optional override config directory to search, for support of multiple target types The command line arguments to parse A hotfix directory where modifications/additions to config files can be read from If specified, this hierarchy will unclude plugins enabled for the given target type The requested config hierarchy

Gets a list of ConfigFields for the given type

Type to get configurable fields for List of config fields for the given type

Read config settings for the given object

Path to the project directory The platform being built Object to receive the settings Optional override config directory to search, for support of multiple target types

Read config settings for the given object

Path to the project directory The platform being built Object to receive the settings Will be populated with config values that were retrieved. May be null. Command line arguments, if null the application's command line arguments will be used Optional override config directory to search, for support of multiple target types

Attempts to parse the given text into an object which matches a specific field type

The text to parse The type of field to parse If successful, a value of type 'FieldType' True if the value could be parsed, false otherwise

Calculates the path to where the project's Default config of the type given (ie DefaultEngine.ini)

Game, Engine, etc Project directory, used to find Config/Default[Type].ini

Calculates the path to where the project's platform specific config of the type given (ie DefaultEngine.ini)

Game, Engine, etc Project directory, used to find Config/Default[Type].ini Platform name

Updates a section in a Default***.ini, and will write it out. If the file is not writable, p4 can attempt to check it out.

Game, Engine, etc Project directory, used to find Config/Default[Type].ini How to modify the secion Name of the section with the Key in it Key to update Value to write for te Key Logger for output

Updates a section in a Default***.ini, and will write it out. If the file is not writable, p4 can attempt to check it out.

Game, Engine, etc Project directory, used to find Config/Default[Type].ini Platform name. Must have a directory under projects Platforms subdirectory How to modify the secion Name of the section with the Key in it Key to update Value to write for te Key Logger for output

Updates a section in config file, and will write it out. If the file is not writable, p4 can attempt to check it out.

Config file (.ini) name How to modify the secion Name of the section with the Key in it Key to update Value to write for te Key Logger for output

Invalidates the hierarchy internal caches so that next call to ReadHierarchy will re-read from disk but existing ones will still be valid with old values

Specifies the action to take for a config line, as denoted by its prefix.

Assign the value to the key

Add the value to the key (denoted with +X=Y in config files)

Remove the key without having to match value (denoted with !X in config files)

Remove the matching key and value (denoted with -X=Y in config files)

Contains a pre-parsed raw config line, consisting of action, key and value components.

The action to take when merging this key/value pair with an existing value

Name of the key to modify

Value to assign to the key

Whether to preserve enclosing quotations around

Constructor.

Action to take when merging this key/value pair with an existing value Name of the key to modify Value to assign

Constructor.

Action to take when merging this key/value pair with an existing value Name of the key to modify Value to assign Whether to preserve enclosing quotations around

Formats this object for the debugger

The original config line

Contains the lines which appeared in a config section, with all comments and whitespace removed

Name of the section

Lines which appeared in the config section

Construct an empty config section with the given name

Name of the config section

try to get a line using it's name, if the line doesn't exist returns false

Name of the line you want to get The result of the operation return true if the line is retrieved return false and null OutLine if Name isn't found in this section

Represents a single config file as stored on disk.

Maps names to config sections

Static (class) constructor which is called before any ConfigFile instance is created

Constructs a new, empty config file

The default action to take when encountering arrays without a '+' prefix

Reads config data from the given file.

File to read from The default action to take when encountering arrays without a '+' prefix

Reads config data from the given string.

Single line string of config settings in the format [Section1]:Key1=Value1,[Section2]:Key2=Value2 The default action to take when encountering arrays without a '+' prefix

Try to parse a key/value pair from the given line, and add it to a config section

The section to receive the parsed config line Optional map to change names of keys on read Optional map to change names of keys on read Text to parse Index of the first non-whitespace character in this line Index of the last (exclusive) non-whitespace character in this line The default action to take if '+' or '-' is not specified on a config line The sections to find the redirected section for receiving the config line True if the line was parsed correctly, false otherwise

Names of sections in this file

Tries to get a config section by name, or creates one if it doesn't exist

Name of the section to look for The config section

Tries to get a config section by name

Name of the section to look for On success, the config section that was found True if the section was found, false otherwise

Write the config file out to the given location. Useful for debugging.

The file to write

Attribute indicating a value which should be populated from a UE .ini config file

Name of the config hierarchy to read from

Section containing the setting

Key name to search for

Constructor

Type of the config hierarchy to read from Section containing the setting Key name to search for. Optional; uses the name of the field if not set.

Types of config file hierarchy

BaseGame.ini, DefaultGame.ini, etc...

BaseEngine.ini, DefaultEngine.ini, etc...

BaseEditor.ini, DefaultEditor.ini, etc...

BaseEditorPerProjectUserSettings.ini, DefaultEditorPerProjectUserSettings.ini, etc..

BaseEncryption.ini, DefaultEncryption.ini, etc..

BaseCrypto.ini, DefaultCrypto.ini, etc..

BaseEditorSettings.ini, DefaultEditorSettings.ini, etc...

BaseInstallBundle.ini, DefaultInstallBundle.ini, etc...

BasePakFileRules.ini, DefaultPakFileRules.ini, etc, etc....

Stores a set of merged key/value pairs for a config section

Map of key names to their values

Construct a merged config section from the given per-file config sections

Config sections from individual files

Returns a list of key names

Tries to find the value for a given key

The key name to search for On success, receives the corresponding value True if the key was found, false otherwise

Tries to find the values for a given key

The key name to search for On success, receives a list of the corresponding values True if the key was found, false otherwise

Encapsulates a hierarchy of config files, merging sections from them together on request

Array of

Cache of requested config sections

Lock for NameToSection

Construct a config hierarchy from the given files

Set of files to include (in order)

Names of all sections in all config files

Finds a config section with the given name

Name of the section to look for The merged config section

Legacy function for ease of transition from ConfigCacheIni to ConfigHierarchy. Gets a bool with the given key name.

Section name Key name Value associated with the specified key. If the key has more than one value, only the first one is returned True if the key exists

Legacy function for ease of transition from ConfigCacheIni to ConfigHierarchy. Gets an array with the given key name, returning null on failure.

Section name Key name Value associated with the specified key. If the key has more than one value, only the first one is returned True if the key exists

Legacy function for ease of transition from ConfigCacheIni to ConfigHierarchy. Gets a string with the given key name, returning an empty string on failure.

Section name Key name Value associated with the specified key. If the key has more than one value, only the first one is returned True if the key exists

Legacy function for ease of transition from ConfigCacheIni to ConfigHierarchy. Gets an int with the given key name.

Section name Key name Value associated with the specified key. If the key has more than one value, only the first one is returned True if the key exists

Gets a single string value associated with the specified key.

Section name Key name Value associated with the specified key. If the key has more than one value, only the first one is returned True if the key exists

Gets a single bool value associated with the specified key.

Section name Key name Value associated with the specified key. If the key has more than one value, only the first one is returned True if the key exists

Gets a single Int32 value associated with the specified key.

Section name Key name Value associated with the specified key. If the key has more than one value, only the first one is returned True if the key exists

Gets a single GUID value associated with the specified key.

Section name Key name Value associated with the specified key. If the key has more than one value, only the first one is returned True if the key exists

Gets a single-precision floating point value associated with the specified key.

Section name Key name Value associated with the specified key. If the key has more than one value, only the first one is returned True if the key exists

Gets a double-precision floating point value associated with the specified key.

Section name Key name Value associated with the specified key. If the key has more than one value, only the first one is returned True if the key exists

Gets an enumeration value associated with the specified key.

Section name Key name Value associated with the specified key. If the key has more than one value, only the first one is returned True if the key exists

Gets all values associated with the specified key

Section where the key is located Key name Copy of the list containing all values associated with the specified key True if the key exists

Gets the value for the given type. Can return a full struct hierarchy.

Section where the key is located Key name Value hierarchy associated with the specified key. All field names must exist True if the key exists and could be parsed

Gets the array of values for the given type. Can return a full struct hierarchy.

Section where the key is located Key name Array of values associated with the specified key. All field names must exist True if the key exists and could be parsed

Parse a string as a boolean value

The text to parse The parsed value, if successful True if the text was parsed, false otherwise

Parse a string as an integer value

The text to parse The parsed value, if successful True if the text was parsed, false otherwise

Parse a string as a GUID value

The text to parse The parsed value, if successful True if the text was parsed, false otherwise

Parse a string as a single-precision floating point value

The text to parse The parsed value, if successful True if the text was parsed, false otherwise

Parse a string as a double-precision floating point value

The text to parse The parsed value, if successful True if the text was parsed, false otherwise

Attempts to parse the given line as a UE config object (eg. (Name="Foo",Number=1234)).

Line of text to parse Receives key/value pairs for the config object True if an object was parsed, false otherwise

Attempts to parse the given line as a UE config array (eg. ("one", "two", "three") ).

Line of text to parse Receives array for the config array True if an array was parsed, false otherwise

Attempts to parse the given line as a UE map (eg. (("key1","value1"), ("key2","value2")).

Line of text to parse Receives dictionary for the config map True if a map was parsed, false otherwise

Returns a list of INI filenames for the given project

Returns a list of INI filenames for the given project

Determines the path to the generated config directory (same as FPaths::GeneratedConfigDir())

Determes the path to the game-agnostic saved directory (same as FPaths::GameAgnosticSavedDir())

Returns the platform name to use as part of platform-specific config files

Gets an ini setting, and then pulls the value for a property out of a struct, in the format: [SomeSection] SomeStruct=(Foo=Bar,Prop="My Value")

Ini section ('SomeSection' in this example) Name of the struct setting ('SomeStruct' in this example) Name of the property inside the struct ('Prop' in this example) The value retrieved from the struct ('My Value' in this example), or null if anything was not found

Pulls the value for a property out of a struct in the given input, in the format: (Foo=Bar,Prop="My Value")

The entire struct as retrieved from the ini via GetString() Name of the property inside the struct ('Prop' in this example) Pass true when the value pulled is an array, like (Foo=(X=1,Y=2)), this would return X=1,Y=2 The value retrieved from the struct ('My Value' in this example), or null if anything was not found

Gets an ini setting, and then pulls the value for a property out of a map, in the format: [SomeSection] SomeMap=((Foo=Bar),(SomeKey="My Value"))

Ini section ('SomeSection' in this example) Name of the struct setting ('SomeMap' in this example) Name of the key inside the struct ('SomeKey' in this example) The value retrieved from the map ('My Value' in this example), or null if anything was not found

Pulls the value for a property out of a struct in the given input, in the format: ((Foo=Bar),(SomeKey="My Value"))

The entire struct as retrieved from the ini via GetString() Name of the key inside the struct ('SomeKey' in this example). Key cannot have escaped quotes or commas The value retrieved from the map ('My Value' in this example), or null if anything was not found

Load a ini value for the given key, then use GetStructKeyValuePairs to return the key/value pairs of the struct

Ini section to read from Name of the ini key to read from Dictionary of struct vars/values

Given a string input (a struct loaded from a .ini file usually), like (Foo=A, Bar="Hello world"), this will return a dictionary of all values, with quotes trimmed off In this example, { { Foo, A } , { Bar, Hello world } }

String containing a struct representation Dictionary of struct vars/values

Functionality for parsing values from a config value

Attempts to parse the given line as the given type. Struct member variables are expected to match

Type to attempt to parse Line of text to parse Receives parse result True if the parse was successful, false otherwise

Attempts to parse the given line as the given template type

Line of text to parse Receives parse result True if the parse was successful, false otherwise

Attempts to parse the given array of lines as array of the given template type

Line of text to parse Receives parse result True if the parse was successful, false otherwise

Identifier for a config file key, including information about the hierarchy used to read it

The config hierarchy type

Project directory to read config files from

The platform being built

The section name

The key name

Constructor

The config hierarchy type Project directory to read config files from The platform being built The section name The key name

Construct a key from an archive

Archive to read from

Writes this key to an archive

Archive to write to

Tests whether this key is equal to another object

The object to compare to True if the keys are equal, false otherwise

Tests whether this key is equal to another key

The key to compare to True if the keys are equal, false otherwise

Gets a hash code for this object

Hash code for the object

Stores a list of config key/value pairs that have been read

The dependencies list

Constructor

Construct an object from an archive on disk

Archive to read from

Write the dependencies object to disk

Archive to write to

Checks whether the list of dependencies is still valid

Compiler configuration. This controls whether to use define debug macros and other compiler settings. Note that optimization level should be based on the bOptimizeCode variable rather than this setting, so it can be modified on a per-module basis without introducing an incompatibility between object files or PCHs.

Specifies which language standard to use. This enum should be kept in order, so that toolchains can check whether the requested setting is >= values that they support.

Supports C++14. No longer supported, code may not compile with this version.

Supports C++17. No longer supported, code may not compile with this version.

Supports C++20

Latest standard supported by the compiler

Use the default standard version (BuildSettingsVersion.V1-V3: Cpp17, V4: Cpp20)

Use the default standard version for engine modules

Specifies which C language standard to use. This enum should be kept in order, so that toolchains can check whether the requested setting is >= values that they support.

Supports no additional standard version flag

Supports C89

Supports C99

Supports C11

Supports C17

Latest standard supported by the compiler

Use the default standard version

Specifies the architecture for code generation on x64 for windows platforms. Note that by enabling this you are changing the minspec for the PC platform, and the resultant executable will crash on machines without AVX support. For more details please see https://learn.microsoft.com/en-us/cpp/build/reference/arch-x64

No minimum architecure

Enables the use of Intel Advanced Vector Extensions instructions

Enables the use of Intel Advanced Vector Extensions 2 instructions

Enables the use of Intel Advanced Vector Extensions 512 instructions

Use the default minimum architecure

The optimization level that may be compilation targets for C# files.

The possible interactions between a precompiled header and a C++ file being compiled.

Encapsulates the compilation output of compiling a set of C++ files.

Encapsulates the environment that a C++ file is compiled in.

The platform to be compiled/linked for.

The configuration to be compiled/linked for.

The architecture that is being compiled/linked (empty string by default)

Gets the Architecture in the normal case where there is a single Architecture in Architectures

Cache of source file metadata

Templates for shared precompiled headers

The name of the header file which is precompiled.

Whether the compilation should create, use, or do nothing with the precompiled header.

Will replace pch with ifc and use header units instead

Whether artifacts from this compile are shared with other targets. If so, we should not apply any target-wide modifications to the compile environment.

Use run time type information

Whether to direct MSVC to remove unreferenced COMDAT functions and data.

zc-inline-remove-unreferenced-comdat

Use Position Independent Executable (PIE). Has an overhead cost

Use Stack Protection. Has an overhead cost

Enable inlining.

Whether to compile ISPC files.

Enable buffer security checks. This should usually be enabled as it prevents severe security risks.

Whether the AutoRTFM compiler is being used or not.

Disables AutoRTFM instrumentation to this cpp file only when AutoRTFMCompiler is enabled

Whether AutoRTFM instrumentation is enabled or not.

Whether AutoRTFM verification is enabled or not.

If unity builds are enabled this can be used to override if this specific module will build using Unity. This is set using the per module configurations in BuildConfiguration.

The number of source files in this module before unity build will be activated for that module. If set to anything besides -1, will override the default setting which is controlled by MinGameModuleSourceFilesForUnityBuild

The minimum number of files that must use a pre-compiled header before it will be created and used.

Module uses a #import so must be built locally when compiling with SN-DBS

Whether to retain frame pointers

Enable exception handling

Enable objective C exception handling

Enable objective C automatic reference counting (ARC) If you set this to true you should not use shared PCHs for this module. The engine won't be extensively using ARC in the short term Not doing this will result in a compile errors because shared PCHs were compiled with different flags than consumer

How to treat any warnings in the code

Whether to warn about deprecated variables

Whether to warn about the use of shadow variables

How to treat unsafe implicit type cast warnings (e.g., double->float or int64->int32)

Indicates what warning/error level to treat undefined identifiers in conditional expressions.

Whether to treat all warnings as errors

Whether to disable all static analysis - Clang, MSVC, PVS-Studio.

Enable additional analyzer extension warnings using the EspXEngine plugin. This is only supported for MSVC. See https://learn.microsoft.com/en-us/cpp/code-quality/using-the-cpp-core-guidelines-checkers This will add a large number of warnings by default. It's recommended to use StaticAnalyzerRulesets if this is enabled.

The static analyzer rulesets that should be used to filter warnings. This is only supported for MSVC. See https://learn.microsoft.com/en-us/cpp/code-quality/using-rule-sets-to-specify-the-cpp-rules-to-run

The static analyzer checkers that should be enabled rather than the defaults. This is only supported for Clang.

The static analyzer default checkers that should be disabled. Unused if StaticAnalyzerCheckers is populated. This is only supported for Clang.

The static analyzer non-default checkers that should be enabled. Unused if StaticAnalyzerCheckers is populated. This is only supported for Clang.

The PVS Studio analysis warnings that should be disabled.

True if compiler optimizations should be enabled. This setting is distinct from the configuration (see CPPTargetConfiguration).

True if the compilation should produce tracing output for code coverage.

Allows to fine tune optimizations level for speed and\or code size

Determines the FP semantics.

True if debug info should be created.

True if debug info should only generate line number tables (clang)

True if we're compiling .cpp files that will go into a library (.lib file)

True if we're compiling a DLL

Whether we should compile using the statically-linked CRT. This is not widely supported for the whole engine, but is required for programs that need to run without dependencies.

Whether to use the debug CRT in debug configurations

Whether to omit frame pointers or not. Disabling is useful for e.g. memory profiling on the PC

Whether we should compile with support for OS X 10.9 Mavericks. Used for some tools that we need to be compatible with this version of OS X.

Whether PDB files should be used for Visual C++ builds.

Whether to just preprocess source files

Should an assembly file be generated while compiling. Works exclusively on MSVC compilers for now.

Whether to support edit and continue. Only works on Microsoft compilers in 32-bit compiles.

Whether to use incremental linking or not.

Whether to allow the use of LTCG (link time code generation)

Whether to enable Profile Guided Optimization (PGO) instrumentation in this build.

Whether to optimize this build with Profile Guided Optimization (PGO).

Platform specific directory where PGO profiling data is stored.

Platform specific filename where PGO profiling data is saved.

Whether to log detailed timing info from the compiler

When enabled, allows XGE to compile pre-compiled header files on remote machines. Otherwise, PCHs are always generated locally.

Ordered list of include paths for the module

The include paths where changes to contained files won't cause dependent C++ source files to be recompiled, unless BuildConfiguration.bCheckSystemHeadersForModification==true.

The include paths which were previously in UserIncludePaths, but are now in a shared response file, persisted in the environment for validation. Do not add to this set unless a shared response is in use, and only when removing those headers from UserIncludePaths.

The include paths which were previously in SystemIncludePaths, but are now in a shared response file, persisted in the environment for validation. Do not add to this set unless a shared response is in use, and only when removing those headers from SystemIncludePaths.

Enumerable of all possible include paths

List of paths to search for compiled module interface (*.ifc) files

Whether headers in system paths should be checked for modification when determining outdated actions.

List of header files to force include

List of files that need to be up to date before compile can proceed

A dictionary of the source file items and the inlined gen.cpp files contained in it

Non-default naming conventions that generated CPP files can have (this uses a filter to check the file name for matches)

FileItems with colliding names. (Which means they would overwrite each other in intermediate folder

The C++ preprocessor definitions to use.

Additional response files that will be used by main response file

Whether the compile environment has a response file in AdditionalResponseFiles that contains global compiler arguments.

Additional arguments to pass to the compiler.

A list of additional frameworks whose include paths are needed.

A dictionary of PCH files for multiple architectures

The instance containing the precompiled header data.

The file containing the precompiled header data.

The parent PCH instance used when creating this PCH.

The parent's PCH header file.

True if a single PRecompiledHeader exists, or at least one PerArchPrecompiledHeaderFile exists

Whether or not UHT is being built

Whether to hide symbols by default

Whether this environment should be treated as an engine module.

Which C++ standard to support for engine modules. CppStandard will be set to this for engine modules and CppStandardEngine should not be checked in any toolchain. May not be compatible with all platforms.

Which C++ standard to support. May not be compatible with all platforms.

Which C standard to support. May not be compatible with all platforms.

Direct the compiler to generate AVX instructions wherever SSE or AVX intrinsics are used. Note that by enabling this you are changing the minspec for the PC platform, and the resultant executable will crash on machines without AVX support.

The amount of the stack usage to report static analysis warnings.

Enable C++ coroutine support. For MSVC, adds "/await:strict" to the command line. Program should #include <coroutine> For Clang, adds "-fcoroutines-ts" to the command line. Program should #include <experimental/coroutine> (not supported in every clang toolchain)

What version of include order specified by the module rules. Used to determine shared PCH variants.

Set flags for determinstic compiles.

Set flags for determinstic compile warnings.

Emits compilation errors for incorrect UE_LOG format strings.

Emits deprecated warnings\errors for internal API usage for non-engine modules.

Directory where to put crash report files for platforms that support it

Default constructor.

Copy constructor.

Environment to copy settings from

Reads the contents of C++ dependency files, and caches them for future iterations.

Contents of a single dependency file

The current file version

Location of this dependency cache

Directory for files to cache dependencies for.

Map from file item to dependency info

Whether the cache has been modified and needs to be saved

Constructs a dependency cache. This method is private; call CppDependencyCache.Create() to create a cache hierarchy for a given project.

File to store the cache Base directory for files that this cache should store data for Logger for output

Reads data for this dependency cache from disk

Writes data for this dependency cache to disk

List of partitions

Static cache of all constructed dependency caches

Minimum version of a MSVC source dependency json

Minimum version of a MSVC source dependency json that supports additional module info

Constructs a dependency cache. This method is private; call CppDependencyCache.Create() to create a cache hierarchy for a given project.

Gets the produced module from a dependencies file

The dependencies file Logger for output The produced module name True if a produced module was found

Attempts to get a list of imported modules for the given file

The dependency file to query Logger for output List of imported modules True if a list of imported modules was obtained

Attempts to read the dependencies from the given input file

File to be read Logger for output Receives a list of output items True if the input file exists and the dependencies were read

Attempts to read the dependencies from the given input file

File to be read Logger for output The dependency info True if the input file exists and the dependencies were read

Attempts to read dependencies from the given file.

File to be read The dependency info True if the input file exists and the dependencies were read

Attempts to read the dependencies from the given input file. This static version will not use any caches.

File to be read Receives a list of output items True if the input file exists and the dependencies were read

Creates a cache hierarchy for a particular target

Target descriptor being built The target type Logger for output Dependency cache hierarchy for the given project

Creates a cache hierarchy for a particular target

Project file for the target being built Name of the target Platform being built Configuration being built The target type The target architectures Intermediate environment to use Logger for output Dependency cache hierarchy for the given project

Reads a cache from the given location, or creates it with the given settings

File to store the cache Base directory for files that this cache should store data for Logger for output Reference to a dependency cache with the given settings

Save all the caches that have been modified

Reads dependencies from the given file.

The file to read from List of included dependencies

Attempts to read a single token from a makefile

Text to read from Current position within the file Receives the token characters True if a token was read, false if the end of the buffer was reached

Builds a reverse lookup table for finding all source files that includes a set of headers

Parses include directives from cpp source files, to make dedicated PCHs

Copies include directives from one file to another, until an unsafe directive (or non-#include line) is found.

Stream to read from Stream to write directives to

Reads an individual token from the input stream

Stream to read from Buffer to store token read from the stream True if a token was read, false otherwise

Stores custom build steps to be executed by a project or plugin

Construct a custom build steps object from a Json object.

Reads a list of build steps from a Json project or plugin descriptor

The json descriptor object Name of the field to read Output variable to store the sorted dictionary that was read True if the field was read (and OutBuildSteps is set), false otherwise.

Reads a list of build steps from a Json project or plugin descriptor

Writer to receive json output Name of the field to read True if the field was read (and OutBuildSteps is set), false otherwise.

Converts this object to a JsonObject to be saved or manipulated.

The JsonObject representation of this object.

Tries to get the commands for a given host platform

The host platform to look for Array of commands True if a list of commands was generated

Class to manage looking up data driven platform information (loaded from .ini files instead of in code)

All data driven information about a platform

Is the platform a confidential ("console-style") platform

Is the platform enabled on this host platform

If true, this platform can stage the crashreporter

Additional restricted folders for this platform.

the compression format that this platform wants; overrides game unless bForceUseProjectCompressionFormat

The online account can't be set from the command line

Entire ini parent chain, ending with this platform

The raw DataDrivenPlatformInfo.ini file

Return all data driven infos found

Return the data driven info for the given platform name

Return the data driven info for the given UnrealTargetPlatform

General deploy support functions, exported for UAT

The max length of the deploy folder name.

Gets the default deploy folder name on the format ShortProjectName-RootDirectoryName-UserName, truncated to DeployFolderMaxLength characters, with dots '.' and whitespace ' ' stripped.

Project to deploy The default deploy folder name.

Methods for dynamically compiling C# source files

Checks to see if the assembly needs compilation

Set of source files File containing information about this assembly, like which source files it was built with and engine version Output path for the assembly Logger for output True if the assembly needs to be built

Dynamically compiles an assembly for the specified source file and loads that assembly into the application's current domain. If an assembly has already been compiled and is not out of date, then it will be loaded and no compilation is necessary.

Full path to the assembly to be created List of source file name Logger for output The assembly that was loaded

Helper functions for dealing with encryption and pak signing

Wrapper class for a single RSA key

Exponent

Modulus

Determine if this key is valid

Wrapper class for an RSA public/private key pair

Public key

Private key

Determine if this key is valid

Returns TRUE if this is a short key from the old 256-bit system

Wrapper class for a 128 bit AES encryption key

Optional name for this encryption key

Optional guid for this encryption key

AES key

Determine if this key is valid

Wrapper class for all crypto settings

AES encyption key

RSA public/private key

Enable pak signature checking

Encrypt the index of the pak file. Stops the pak file being easily accessible by unrealpak

Encrypt all ini files in the pak. Good for game data obsfucation

Encrypt the uasset files in the pak file. After cooking, uasset files only contain package metadata / nametables / export and import tables. Provides good string data obsfucation without the downsides of full package encryption, with the security drawbacks of still having some data stored unencrypted

Encrypt all assets data files (including exp and ubulk) in the pak file. Likely to be slow, and to cause high data entropy (bad for delta patching)

Some platforms have their own data crypto systems, so allow the config settings to totally disable our own crypto

Config setting to enable pak encryption

Config setting to enable pak signing

A set of named encryption keys that can be used to encrypt different sets of data with a different key that is delivered dynamically (i.e. not embedded within the game executable)

Returns whether the specified encryption key exist.

Helper class for formatting incoming hex signing key strings

Helper function for comparing two AES keys

Parse crypto settings from INI file

Take a hex string and parse into an array of bytes

Information about a module that needs to be passed to UnrealHeaderTool for code generation

Module name

Path to the module rules file

Paths to all potential module source directories (with platform extension directories added in)

The include search path for generated headers to include other headers

Module type

Overridden package module type to add more flags

Public UObject headers found in the Classes directory (legacy)

Public headers with UObjects

Internal headers with UObjects

Private headers with UObjects

Directory containing generated code

Collection of the module's public defines

Path and base filename, without extension, of the .gen files

Version of code generated by UHT

Whether this module is read-only

Path of the verse generated types

Scope of the verse definitions

If true, verse scripts were found

Verse plugin name

This handles all running of the UnrealHeaderTool

Gets the module type for a given rules object

The rules object Descriptor for the project being built The module type

Find all the headers under the given base directory, excluding any other platform folders.

Base directory to search Array of folders to exclude Receives the list of headers that was found

Gets UnrealHeaderTool.exe path. Does not care if UnrealheaderTool was build as a monolithic exe or not.

Gets the latest write time of any of the UnrealHeaderTool binaries (including DLLs and Plugins) or DateTime.MaxValue if UnrealHeaderTool does not exist

Latest timestamp of UHT binaries or DateTime.MaxValue if UnrealHeaderTool is out of date and needs to be rebuilt.

Gets the timestamp of CoreUObject.gen.cpp file.

Last write time of CoreUObject.gen.cpp or DateTime.MaxValue if it doesn't exist.

Checks the class header files and determines if generated UObject code files are out of date in comparison.

Build configuration Modules that we generate headers for Timestamp for UHT Logger for output True if the code files are out of date

Determines if any external dependencies for generated code is out of date

Path to the external dependencies file True if any external dependencies are out of date

Updates the recorded timestamps of all the passed in UObject modules

Run an external native executable (and capture the output), given the executable path and the commandline.

Simple function to pipe output asynchronously

Builds and runs the header tool and touches the header directories. Performs any early outs if headers need no changes, given the UObject modules, tool path, game name, and configuration

Return the file reference for the UHT manifest file

Input makefile Name of the target Manifest file name

Return the file reference for the UHT deps file

Manifest info file name UHT dependency file name

Convert the makefile to a UHTManifest object

Input makefile Name of the target Name of the dependencies file. Output UHT manifest

Write the manifest to disk

Input makefile Name of the target Destination file name. If not supplied, it will be generated. Name of the dependencies file. If not supplied, it will be generated.

Return the latest of two date/times

First date/time to compare Second date/time to compare Latest of the two dates

Builds and runs the header tool and touches the header directories. Performs any early outs if headers need no changes, given the UObject modules, tool path, game name, and configuration

Prefetches metadata from the filesystem, by populating FileItem and DirectoryItem objects for requested directory trees. Since

Queue for tasks added to the thread pool

Used to cancel any queued tasks

The cancellation token

Set of all the directory trees that have been queued up, to save adding any more than once.

Enqueue the engine directory for prefetching

Enqueue a project directory for prefetching

The project directory to prefetch

Enqueue a directory tree for prefetching

Directory to start searching from

Wait for the prefetcher to complete all reqeusted tasks

Stop prefetching items, and cancel all pending tasks. synchronous.

Enqueue a task which checks for the cancellation token first

Action to enqueue

Scans the engine directory, adding tasks for subdirectories

Scans a project directory, adding tasks for subdirectories

The project directory to search

Scans a plugin parent directory, adding tasks for subdirectories

The directory which may contain plugin directories

Scans an arbitrary directory tree

Root of the directory tree

A single "node" in a directed graph

Describes an edge in the directed graph

Attribute for a graph node

Gexf ID for this attribute Name of the attribute Gexf type name

Writes a GEXF graph file for the specified graph nodes and edges

The file name to write The description to include in the graph file's metadata List of all graph nodes. Index order is important and must match with the individual node Id members! List of all graph edges. Index order is important and must match with the individual edge Id members!

The current hot reload mode

Stores the current hot reload state, tracking temporary files created by previous invocations.

Suffix to use for the next hot reload invocation

Map from original filename in the action graph to hot reload file

Set of all temporary files created for hot reload

Adds all the actions into the hot reload state, so we can restore the action graph on next iteration

The actions being executed Mapping from file from their original location (either a previously hot-reloaded file, or an originally compiled file)

Gets the location of the hot-reload state file for a particular target

Descriptor for the target Location of the hot reload state file

Gets the location of the hot-reload state file for a particular target

Project containing the target Name of the target Platform being built Configuration being built Architecture(s) being built Location of the hot reload state file

Read the hot reload state from the given location

Location to read from New hot reload state instance

Writes the state to disk

Location to write to

Contents of the JSON version of the live coding modules file

These modules have been loaded by a process and are enabled for patching

These modules have been loaded by a process, but not explicitly enabled

Getts the default hot reload mode for the given target

The target being built Makefile for the target Global build configuration Logger for output Default hotreload mode

Sets the appropriate hot reload mode for a target, and cleans up old state.

The target being built Makefile for the target Actions for this target Global build configuration Logger for output

Checks whether a live coding session is currently active for a target. If so, we don't want to allow modifying any object files before they're loaded.

Makefile for the target being built Logger for output True if a live coding session is active, false otherwise

Checks if the editor is currently running and this is a hot-reload

Delete all temporary files created by previous hot reload invocations

Location of the state file Logger for output

Apply a saved hot reload state to a makefile

The hot-reload state Makefile to apply the state Actions for this makefile

Given a collection of strings which are file paths, create a hash set from the file name and extension. Empty strings are eliminated.

Source collection Trimmed and unique collection

Determine what needs to be built for a target

The build configuration Target being built Makefile generated for this target The actions to execute Actions to execute for this target Collection of all the renamed as part of module reload requests. Can be null Logger for output Set of actions to execute

Replaces a hot reload suffix in a filename.

Replaces a base filename within a string. Ensures that the filename is not a substring of another longer string (eg. replacing "Foo" will match "Foo.Bar" but not "FooBar" or "BarFooBar").

Text to replace within Old filename New filename Text with file names replaced

Determines if a character should be treated as part of a base filename, when updating strings for hot reload

The character to check True if the character is part of a base filename, false otherwise

Test to see if the action is an action live coding supports. All other actions will be filtered

Action in question True if the action is a compile action for the compiler. This filters out RC compiles.

Patches a set of actions for use with live coding. The new action list will output object files to a different location.

Set of actions Dictionary that receives a map of original object file to patched object file Requested hot reload mode

Patch the action graph for hot reloading, mapping files according to the given dictionary.

Patches a set of actions to use a specific list of suffixes for each module name

Map of module name to suffix Makefile for the target being built Actions to be executed for this makefile Collection of file names patched. Can be null.

Writes a manifest containing all the information needed to create a live coding patch

File to write to List of actions that are part of the graph Map of original object files to patched object files

The project type that support is required for

Support for code projects

Support for deploying content projects

The state of a downloaded platform

Query whether the platform is supported

Query whether the platform has been downloaded

Contains methods to allow querying the available installed platforms

Information about a single installed platform configuration

Build Configuration of this combination

Platform for this combination

Type of Platform for this combination

Architecture for this combination

Location of a file that must exist for this combination to be valid (optional)

Type of project this configuration can be used for

Whether to display this platform as an option even if it is not valid

Constructor

Initializes the InstalledPlatformInfo. While this is not necessary to be called, it allows timing the static constructor call.

Determine if the given configuration is available for any platform

Configuration type to check The type of project True if supported

Determine if the given platform is available

Platform to check The type of project True if supported

Determine whether the given platform/configuration/project type combination is supported

Configuration for the project Platform for the project Type of the project True if the combination is supported

Determines whether the given target type is supported

The target type being built The platform being built The configuration being built The project type required State of the given platform support True if the target can be built

Loads JunkManifest.txt file and removes all junk files/folders defined in it.

Loads JunkManifest.txt file.

Junk manifest file contents.

Goes through each entry from the junk manifest and deletes it.

JunkManifest.txt entries. Logger for output

Deletes a directory recursively gracefully handling all exceptions.

Path. Logger for output

Deletes a file gracefully handling all exceptions.

Filename. Logger for output

Encapsulates the environment that is used to link object files.

The platform to be compiled/linked for.

The configuration to be compiled/linked for.

The architecture that is being compiled/linked (empty string by default)

Gets the Architecture in the normal case where there is a single Architecture in Architectures

On Mac, indicates the path to the target's application bundle

The directory to put the non-executable files in (PDBs, import library, etc)

Intermediate file directory

The directory to shadow source files in for syncing to remote compile servers

The file path for the executable file that is output by the linker.

Returns the OutputFilePath is there is only one entry in OutputFilePaths

List of libraries to link in

A list of additional libraries to link in (using the list of library search paths)

A list of the paths used to find libraries.

A list of libraries to exclude from linking.

Paths to add as search paths for runtime libraries

A list of additional frameworks to link in.

The iOS/Mac frameworks to link in

iOS/Mac resources that should be copied to the app bundle

A list of the dynamically linked libraries that shouldn't be loaded until they are first called into.

Per-architecture lists of dependencies for linking to ignore (useful when building for multiple architectures, and a lib only is needed for one architecture), it's up to the Toolchain to use this

Additional arguments to pass to the linker.

True if debug info should be created.

True if runtime symbols files should be generated as a post build step for some platforms. These files are used by the engine to resolve symbol names of callstack backtraces in logs.

True if debug symbols that are cached for some platforms should not be created.

True if we're compiling .cpp files that will go into a library (.lib file)

True if we're compiling a DLL

The method of linking the target uses

Whether we should compile using the statically-linked CRT. This is not widely supported for the whole engine, but is required for programs that need to run without dependencies.

Whether to use the debug CRT in debug configurations

True if this is a console application that's being build

If set, overrides the program entry function on Windows platform. This is used by the base Unreal program so we can link in either command-line mode or windowed mode without having to recompile the Launch module.

True if we're building a EXE/DLL target with an import library, and that library is needed by a dependency that we're directly dependent on.

True if the application we're linking has any exports, and we should be expecting the linker to generate a .lib and/or .exp file along with the target output file

True if we're building a .NET assembly (e.g. C# project)

The default stack memory size allocation

The amount of the default stack size to commit initially. Set to 0 to allow the OS to decide.

Wether to link code coverage / tracing libs

Whether to omit frame pointers or not. Disabling is useful for e.g. memory profiling on the PC

Whether to support edit and continue. Only works on Microsoft compilers in 32-bit compiles.

Whether to use incremental linking or not.

Whether to allow the use of LTCG (link time code generation)

Whether to enable Profile Guided Optimization (PGO) instrumentation in this build.

Whether to optimize this build with Profile Guided Optimization (PGO).

Platform specific directory where PGO profiling data is stored.

Platform specific filename where PGO profiling data is saved.

Platform specific filename where pre-merged PGO profiling data is saved.

Whether to request the linker create a map file as part of the build

Whether PDB files should be used for Visual C++ builds.

Whether to use the :FASTLINK option when building with /DEBUG to create local PDBs

Use Position Independent Executable (PIE). Has an overhead cost

Whether to ignore dangling (i.e. unresolved external) symbols in modules

Set flags for determinstic compiles.

Whether to log detailed timing information

Package full path (directory + filename) where to store input files used at link time Normally used to debug a linker crash for platforms that support it

Directory where to put crash report files for platforms that support it

Directory where to put the ThinLTO cache for platforms that support it

Arguments that will be applied to prune the ThinLTO cache for platforms that support it. The arguments will only be applied if ThinLTOCacheDirectory is set.

Bundle version for Mac apps

When building a dynamic library on Apple platforms, specifies the installed name for other binaries that link against it.

A list of the object files to be linked.

The default resource file to link in to every binary if a custom one is not provided

Resource files which should be compiled into every binary

List of functions that should be exported from this module

Debugger visualizer files to build into debug info for this binary.

Provides a Module Definition File (.def) to the linker to describe various attributes of a DLL. Necessary when exporting functions by ordinal values instead of by name.

All the additional properties from the modules linked into this binary

List of all of the runtime dependencies.

Default constructor.

Copy constructor.

Construct a LinkEnvironment from another, and filter it down to only files/dependencies that apply to the given architecture

Parent LinkEnvironment to start with that may have been created from multiple architectures (arch1+arch2) The single architecture to filter down to

Manifest file (.loadorder) describing the order in which all dynamic modules should be loaded. For this reason, it's only relevant to modular builds on some platforms. This file exists because on some non-Windows platforms dynamic modules (such as DLLs) don't support dependencies and it's our responsibility to load them in the right order (Windows DLLs know which other DLLs they rely on and these dependencies are guaranteed to be loaded first). If we fail respect this order, we're likely to get crashes e.g. when global statics are being initialized because some dereferenced globals may not be available yet (null).

List of all project's dynamic modules in the order in which they should be loaded. All paths are relative to the main binary's directory.

Gets a filename for a load order manifest for a build with the given platform/configuration.

The modular app name being built The target configuration The target platform The architecture of the target platform Filename for the app receipt

Read the load order manifest from a file.

Filename to read from The receipt that was read

Write the load order manifest to a file.

Filename to write to

Write the load order manifest to a text writer.

The writer to output to

How this localization target should be generated during the localization gather pipeline

This localization target should never have localization config files associated with it during the localization gather pipeline.

This localization target should only use user generated localization config files during the localization gather pipeline.

Default auto-generated localization config files will be used to generate the localization target and localization content files during the localization gather pipeline

Description of a localization target.

Name of this target

When should the localization data associated with a target should be loaded?

How should this localization target's localization config files be generated during a localization gather.

Constructor

Name of the target When should the localization data associated with a target should be loaded?

Constructor

The name of the localization target. When the localization data associated with this localization target should be loaded. How the localization config files should be generated during a localization gather to create the localization data files.

Constructs a LocalizationTargetDescriptor from a Json object

The new localization target descriptor

Write this target to a JsonWriter

Writer to output to

Write an array of target descriptors

The Json writer to output to Name of the array Array of targets

Updates a JsonObject with an array of localization target descriptors.

The Json object to update. Name of the array Array of targets

The type of host that can load a module

Any target using the UE runtime

Any target except for commandlet

Any target or program

Loaded only in cooked builds

Loaded only in uncooked builds

Loaded only when the engine has support for developer tools enabled

Loads on any targets where bBuildDeveloperTools is enabled

Loaded only by the editor

Loaded only by the editor, except when running commandlets

Loaded by the editor or program targets

Loaded only by programs

Loaded only by servers

Loaded only by clients, and commandlets, and editor....

Loaded only by clients and editor (editor can run PIE which is kinda a commandlet)

External module, should never be loaded automatically only referenced

Indicates when the engine should attempt to load this module

Loaded at the default loading point during startup (during engine init, after game modules are loaded.)

Right after the default phase

Right before the default phase

Loaded as soon as plugins can possibly be loaded (need GConfig)

Loaded before the engine is fully initialized, immediately after the config system has been initialized. Necessary only for very low-level hooks

The first screen to be rendered after system splash screen

After PostConfigInit and before coreUobject initialized. used for early boot loading screens before the uobjects are initialized

Loaded before the engine is fully initialized for modules that need to hook into the loading screen before it triggers

After the engine has been initialized

Do not automatically load this module

Class containing information about a code module

Name of this module

Usage type of module

When should the module be loaded during the startup sequence? This is sort of an advanced setting.

List of allowed platforms

List of disallowed platforms

List of allowed targets

List of disallowed targets

List of allowed target configurations

List of disallowed target configurations

List of allowed programs

List of disallowed programs

List of allowed game targets

List of disallowed game targets

List of additional dependencies for building this module.

When true, an empty PlatformAllowList is interpreted as 'no platforms' with the expectation that explicit platforms will be added in plugin extensions */

Constructor

Name of the module Type of target that can host this module

Constructs a ModuleDescriptor from a Json object

The new module descriptor

Write this module to a JsonWriter

Writer to output to

Write an array of module descriptors

The Json writer to output to Name of the array Array of modules

Updates a JsonObject with an array of module descriptors

The JsonObject to update. Name of the array Array of modules

Produces any warnings and errors for the module settings

File containing the module declaration

Determines whether the given plugin module is part of the current build.

The platform being compiled for The target configuration being compiled for Name of the target being built The type of the target being compiled Whether the configuration includes developer tools (typically UEBuildConfiguration.bBuildDeveloperTools for UBT callers) Whether the configuration requires cooked content (typically UEBuildConfiguration.bBuildRequiresCookedData for UBT callers)

Attribute which can be applied to a ModuleRules-dervied class to indicate which module groups it belongs to

Array of module group names

Initialize the attribute with a list of module groups

Variable-length array of module group arguments

Stores the version (or a unique build ID) for the modules for a target in a certain folder. This allows the runtime to identify which modules are used for which files, and which version they're at. This prevents stale binaries from being loaded by the runtime when making a local unversioned build, and allows faster incremental builds than compiling the build changelist into every module when making versioned builds.

Unique build id for the modules described in the manifest.

Map of module name to file name.

Constructs the module map with the given changelist

The unique build id

Merge another manifest into this one

The manifest to merge in

Gets the standard path for an manifest

The modular app name being built The target configuration The target platform The architecture of the target platform Filename for the app receipt

Read an app receipt from disk

Filename to read from The receipt that was read

Tries to read a receipt from disk.

The filename that was read If successful, the receipt that was read. Null otherwise. True if the file was read succesfully.

Write the receipt to disk.

The file to write to

Write the receipt to disk.

The writer to output to

Utility functions for querying native projects (ie. those found via a .uprojectdirs query)

Cached map of target names to the project file they belong to

Clear our cached properties. Generally only needed if your script has modified local files...

Get the project folder for the given target name

Name of the target of interest Logger for output The project filename True if the target was found

Returns true if this project is a Hybrid content only project that requires it to be built as code

Creates temporary target files, if needed, for a hybrid content only project

True if the project is hybrid

Determines if a project (given a .uproject file) has source code. This is determined by finding at least one .Target.cs file

Path to a .uproject file If true, search Intermediate/Source for target files True if this is a source-based project

NOTE: This function must mirror the functionality of TargetPlatformBase::RequiresTempTarget

NOTE: This function must mirror FPluginManager::RequiresTempTargetForCodePlugin

NOTE: This function must mirror FPluginManager::GetCodePluginsForTarget

NOTE: This function should mirror FPluginManager::ConfigureEnabledPluginForTarget

Attribute used to denote that a method should no longer be overriden. Used by RulesCompiler.

Message to display to the user if the method is overridden.

Constructor

Message to display to the user if the method is overridden

General platform support functions, exported for UAT

Checks whether the given platform is available

Platform to check True if the platform is available, false otherwise

Gets a list of the registered platforms

List of platforms

Checks whether the given project has a default build configuration

The project file Platform to check settings for True if the project uses the default build configuration

Checks whether the given project requires a build because of platform needs

The project file Platform to check settings for True if the project requires a build for the platform

Returns an array of all platform folder names

All platform folder names

Returns an array of all platform folder names

The platform to get the included folder names for All platform folder names

Returns all the excluded folder names for a given platform

The platform to get the excluded folder names for Array of folder names

Check whether the given platform supports XGE

Platform to check Logger for output True if the platform supports XGE

Check whether the given platform supports the parallel executor in UAT

Platform to check Logger for output True if the platform supports the parallel executor in UAT

Gets the path for the XGE console executable

On success, receives the path to the XGE console executable True if the path was found, false otherwise

Initialize UBT in the context of another host process (presumably UAT)

Command Line arguments that UBT may need access to for initializing platforms Logger for output True if initialization was successful

The version format for .uplugin files. This rarely changes now; plugin descriptors should maintain backwards compatibility automatically.

Invalid

Initial version

Adding SampleNameHash

Unifying plugin/project files (since abandoned, but backwards compatibility maintained)

This needs to be the last line, so we can calculate the value of Latest below

The latest plugin descriptor version

In-memory representation of a .uplugin file

Descriptor version number

Version number for the plugin. The version number must increase with every version of the plugin, so that the system can determine whether one version of a plugin is newer than another, or to enforce other requirements. This version number is not displayed in front-facing UI. Use the VersionName for that.

Name of the version for this plugin. This is the front-facing part of the version number. It doesn't need to match the version number numerically, but should be updated when the version number is increased accordingly.

Friendly name of the plugin

Description of the plugin

The name of the category this plugin

The company or individual who created this plugin. This is an optional field that may be displayed in the user interface.

Hyperlink URL string for the company or individual who created this plugin. This is optional.

Documentation URL string.

Marketplace URL for this plugin. This URL will be embedded into projects that enable this plugin, so we can redirect to the marketplace if a user doesn't have it installed.

Support URL/email for this plugin.

Sets the version of the engine that this plugin is compatible with.

Sets the version of the engine at which this plugin has been deprecated.

4 If true, this plugin from a platform extension extending another plugin */

List of platforms supported by this plugin. This list will be copied to any plugin reference from a project file, to allow filtering entire plugins from staged builds.

List of programs supported by this plugin.

List of all modules associated with this plugin

List of all localization targets associated with this plugin

The Verse path to the root of this plugin's content directory

Origin/visibility of Verse code in this plugin's Content/Verse folder

The version of the Verse language that this plugin targets. If no value is specified, the latest stable version is used.

Whether this plugin should be enabled by default for all projects

Can this plugin contain content?

Can this plugin contain Verse code (either in content directory or in any of its modules)?

Marks the plugin as beta in the UI

Marks the plugin as experimental in the UI

Set for plugins which are installed

For plugins that are under a platform folder (eg. /IOS/), determines whether compiling the plugin requires the build platform and/or SDK to be available

When true, prevents other plugins from depending on this plugin

When true, this plugin should not contain any code or modules.

When true, this plugin's modules will not be loaded automatically nor will it's content be mounted automatically. It will load/mount when explicitly requested and LoadingPhases will be ignored

When true, an empty SupportedTargetPlatforms is interpreted as 'no platforms' with the expectation that explicit platforms will be added in plugin platform extensions

Set of pre-build steps to execute, keyed by host platform name.

Set of post-build steps to execute, keyed by host platform name.

Additional plugins that this plugin depends on

Plugins that this plugin should never depend on

The JsonObject created from reading a .uplugin on disk or from parsing a json text This preserves the order of all the fields from the source json as well as account for any custom fields.

Reads a plugin descriptor from a json object

The object to read from New plugin descriptor

Creates a plugin descriptor from a file on disk preserving all custom fields in the file.

The filename to read New plugin descriptor

Saves the descriptor to disk. This only saves the default fields in a .uplugin and does not account for cusotm fields.

The filename to write to

Saves the descriptor to disk preserving all custom fields that were read in.

The filename to write to

Writes the plugin descriptor to an existing Json writer

The writer to receive plugin data

Produces any warnings and errors for the plugin descriptor

File containing the plugin

Determines if this reference enables the plugin for a given platform

The platform to check True if the plugin should be enabled

Retrieve the list of supported target platforms as a string list

String list of supported target platforms

Indicates whether it is acceptable for the given platform to be missing Typically for platform extensions that are not covered by NDA in third party plugins

Representation of a reference to a plugin from a project file

Name of the plugin

Whether it should be enabled by default

Whether this plugin is optional, and the game should silently ignore it not being present

Description of the plugin for users that do not have it installed.

URL for this plugin on the marketplace, if the user doesn't have it installed.

If enabled, list of platforms for which the plugin should be enabled (or all platforms if blank).

If enabled, list of platforms for which the plugin should be disabled.

If enabled, list of target configurations for which the plugin should be enabled (or all target configurations if blank).

If enabled, list of target configurations for which the plugin should be disabled.

If enabled, list of targets for which the plugin should be enabled (or all targets if blank).

If enabled, list of targets for which the plugin should be disabled.

The list of supported platforms for this plugin. This field is copied from the plugin descriptor, and supplements the user's allowed/denied platforms.

When true, empty SupportedTargetPlatforms and PlatformAllowList are interpreted as 'no platforms' with the expectation that explicit platforms will be added in plugin platform extensions

When set, specifies a specific version of the plugin that this references.

Constructor

Name of the plugin The marketplace URL for plugins which are not installed Whether the plugin is enabled

Construct a PluginReferenceDescriptor from a Json object

The writer for output fields

Write an array of module descriptors

The Json writer to output to Name of the array Array of plugins

Updates the json object with an array of plugin descriptors.

The Json object to update. Name of the array Array of plugins

Checks the given platform names array and logs a message about any that are not known. This may simply be due to not having the platform synced in Engine/Platforms/[PlatformName].

Construct a PluginReferenceDescriptor from a Json object

The Json object containing a plugin reference descriptor New PluginReferenceDescriptor object

Determines if this reference enables the plugin for a given platform

The platform to check True if the plugin should be enabled

Determines if this reference enables the plugin for a given target configuration

The target configuration to check True if the plugin should be enabled

Determines if this reference enables the plugin for a given target

The target to check True if the plugin should be enabled

Determines if this reference is valid for the given target platform.

The platform to check True if the plugin for this target platform

Where a plugin was loaded from

Plugin is built-in to the engine

Project-specific plugin, stored within a game project directory

Where a plugin was loaded from. The order of this enum is important; in the case of name collisions, larger-valued types will take precedence. Plugins of the same type may not be duplicated.

Plugin is built-in to the engine

Project-specific plugin, stored within a game project directory

Plugin found in an external directory (found in an AdditionalPluginDirectory listed in the project file, or referenced on the command line)

Project-specific mod plugin

Information about a single plugin

Plugin name

Path to the plugin

Path to the plugin's root directory

Children plugin files that can be added to this plugin (platform extensions)

The plugin descriptor

The type of this plugin

Used to indicate whether a plugin is being explicitly packaged via the -plugin command line

Constructs a PluginInfo object

Path to the plugin descriptor The type of this plugin

Determines whether the plugin should be enabled by default

Determines where the plugin was loaded from

Represents a group of plugins all sharing the same name -- notionally all different versions of the same plugin. Since UE can only manage a single plugin of a given name (to avoid module conflicts, etc.), this object prioritizes and bubbles up a single "choice" plugin from the set -- see `ChoiceVersion`.

Shared name that all the plugins in the set go by.

Unordered list of all the discovered plugins matching the above name.

Constructor which takes the specified PluginInfo and adds it to the set.

The fist plugin discovered for this set -- will automatically be prioritized as the "choice" plugin.

Pushes the specified PluginInfo into the set, and optionally promotes it to the new "choice" version.

The new plugin to add to this set (its name should match this set's name) Whether or not to make this the new prioritized "choice" plugin in the set.

The single plugin, out of the entire set, that we prioritize to be built and utilized by UE.

An index that we use to identify which plugin in the list is the prioritized "choice" version.

Class for enumerating plugin metadata

Cache of plugins under each directory

Invalidate cached plugin data so that we can pickup new things Warning: Will make subsequent plugin lookups and directory scans slow until the caches are repopulated

Add a means to retrieve a plugin to determine if it is present.

The name of the plugin. The cached plugin info, or null if not found.

Returns a filtered list of plugins as a name:plugin dictionary to ensure that any game plugins override engine plugins with the same name, and otherwise that no two plugins with the same name exist.

List of plugins to filter Filtered Dictionary of plugins

Filters the list of plugins to ensure that any game plugins override engine plugins with the same name, and otherwise that no two plugins with the same name exist.

List of plugins to filter Filtered list of plugins in the original order

Read all the plugins available to a given project

Path to the engine directory Path to the project directory (or null) List of additional directories to scan for available plugins Sequence of PluginInfo objects, one for each discovered plugin

Read all the plugin descriptors under the given engine directory

The parent directory to look in. Sequence of the found PluginInfo object.

Read all the plugin descriptors under the given project directory

The parent directory to look in. Sequence of the found PluginInfo object.

Read all of the plugins found in the project specified additional plugin directories

The additional directory to scan Logger for output List of the found PluginInfo objects

Determines whether the given suffix is valid for a child plugin

Whether the suffix is appopriate

Attempt to merge a child plugin up into a parent plugin (via file naming scheme). Very little merging happens but it does allow for platform extensions to extend a plugin with module files

Child plugin that needs to merge to a main, parent plugin Child plugin's filename, used to determine the parent's name

Read all the plugin descriptors under the given directory

The directory to look in. A subdirectory to look in in RootDirectory and any other Platform directories under Root The plugin type Sequence of the found PluginInfo object.

Determine if a plugin is enabled for a given project

The project to check. May be null. Information about the plugin The target platform The target configuration The type of target being built True if the plugin should be enabled for this project

Determine if a plugin is enabled for a given project

The project to check. May be null. Information about the plugin The target platform The target configuration The type of target being built Whether the target requires cooked data True if the plugin should be enabled for this project

Information about a PCH instance

The file to include to use this shared PCH

The definitions file

The compile environment for this shared PCH

The output files for the shared PCH

List of modules using this instance

These are definitions that are immutable and should never be #undef. There are a few exceptions and we make sure those are not ending up in this list

Parent PCH instance used in PCH chaining

Dictionary of definitions use in the CppCompileEnvironment

Constructor

Return a string representation of this object for debugging

String representation of the object

A template for creating a shared PCH. Instances of it are created depending on the configurations required.

Module providing this PCH.

The base compile environment, including all the public compile environment that all consuming modules inherit.

The header file

Output directory for instances of this PCH.

Instances of this PCH

All the module dependencies this template has

Constructor

The module with a valid shared PCH The compile environment to use The header file to generate a PCH from Output directory for instances of this PCH All the module dependencies this template has

Checks whether this template is valid for the given compile environment

Compile environment to check with True if the template is compatible with the given compile environment

Return a string representation of this object for debugging

String representation of the object

Stores information about a compiled binary or module, including the build products and intermediate folders.

List of files produced by compiling the module. These are within the module output directory.

Default constructor

Read a receipt from disk.

Filename to read from

Try to read a manifest from disk, failing gracefully if it can't be read.

Filename to read from If successful, the manifest that was read True if successful

Write the receipt to disk.

Output filename

Class to display an incrementing progress percentage. Handles progress markup and direct console output.

Global setting controlling whether to output markup

Logger for output

The name to include with the status message

The inner scope object

The current progress message

Constructor

The message to display before the progress percentage Whether to write messages to the console Logger for output

Write the terminating newline

Writes the current progress

Numerator for the progress fraction Denominator for the progress fraction

The version format for .uproject files. This rarely changes now; project descriptors should maintain backwards compatibility automatically.

Invalid

Initial version

Adding SampleNameHash

Unifying plugin/project files (since abandoned, but backwards compatibility maintained)

This needs to be the last line, so we can calculate the value of Latest below

The latest plugin descriptor version

In-memory representation of a .uproject file

Descriptor version number.

The engine to open this project with.

Category to show under the project browser

Description to show in the project browser

List of all modules associated with this project

List of plugins for this project (may be enabled/disabled)

Array of additional root directories

List of additional plugin directories to scan for available plugins

Array of platforms that this project is targeting

A hash that is used to determine if the project was forked from a sample

Steps to execute before creating rules assemblies in this project

Steps to execute before building targets in this project

Steps to execute before building targets in this project

Indicates if this project is an Enterprise project

Indicates that enabled by default engine plugins should not be enabled unless explicitly enabled by the project or target files.

Constructor.

Constructor

Raw JSON object to parse Base directory for resolving relative paths

Creates a plugin descriptor from a file on disk

The filename to read New plugin descriptor

Creates a plugin descriptor based on a directory, searching for best uproject

The directory to search for a uproject New plugin descriptor

If the descriptor has either additional plugin directories or additional root directories then it is considered to have additional paths. The additional paths will be relative to the provided directory.

The directory set to add the paths too. The directory which is used to setup the additional paths

Saves the descriptor to disk

The filename to write to

Writes the plugin descriptor to an existing Json writer

The writer to receive plugin data Base directory to save paths relative to

Names of restricted folders. Note: The name of each entry is used to search for/create folders

Values for RestrictedFolder

Unique Id for this folder

Mapping for unique ids

Array of all restricted folder names

Array of all restricted folders

Set of permitted references for each restricted folder. Determined via data-driven platform info.

Constructor

Id of the string

Creates a restricted folder instance from a string

Name of the folder New restricted folder instance

Tests for equality between two restricted folder instances

First instance Second instance True if the two instances are equal

Tests for inequality between two restricted folder instances

First instance Second instance True if the two instances are not equal

Tests whether two restricted folder instances are equal

The restricted folder to compare against True if the restricted folder is equal to the other instance

Gets a hash code for this object

Hash code for the object

Returns an array of folders which are allowed to be referenced from this restricted folder

Collection of restricted folders

Creates entries for all the confidential platforms. Should be called before returning any list of all folder values.

Gets an array of all the restricted folder names

Ensures that we've added all the restricted folders, and return an array of them

Array of restricted folder values

Return the string representation

Legacy. Should not be used any more.

Can be used by UE but not required

Epic Employees and Contractors as well as some explicitly permitted external groups

Epic Employees and Contractors

Epic Employees only

Utility functions for getting restricted folder

Finds all the restricted folder names relative to a base directory

The base directory to check against The file or directory to check Array of restricted folder names

Finds all the permitted restricted folder references for a given path

The base directory to check against The file or directory to check Array of restricted folder names

Controls how the target and SDK are validated in CreateTargetRulesInstance

This will perform full target validation (allows the platform to update the target to make sure it's valid), and SDK validation (makes sure SDK overrides are not conflicting). This is the standard, default mode.

This will validate the target only (see ValidateTargetAndSDK)

This will validate the SDK only (see ValidateTargetAndSDK)

This will perform neither of the validations

Stores information about a compiled rules assembly and the types it contains

Outers scope for items created by this assembly. Used for chaining assemblies together.

The compiled assembly

Returns the simple name of the assembly e.g. "UE5ProgramRules"

Returns all the types contained in the compiled rules assembly

The base directories for this assembly

All the plugins included in this assembly

Maps module names to their actual xxx.Module.cs file on disk

Maps target names to their actual xxx.Target.cs file on disk

Mapping from module file to its context.

Whether this assembly contains engine modules. Used to set default values for bTreatAsEngineModule.

Whether to use backwards compatible default settings for module and target rules. This is enabled by default for game projects to support a simpler migration path, but is disabled for engine modules.

Whether the modules and targets in this assembly are read-only

The parent rules assembly that this assembly inherits. Game assemblies inherit the engine assembly, and the engine assembly inherits nothing.

The set of files that were compiled to create this assembly

Any preprocessor defines that were set when this assembly was created

Constructor. Compiles a rules assembly from the given source files.

The scope of items created by this assembly The base directories for this assembly All the plugins included in this assembly List of module files to compile List of target files to compile The output path for the compiled assembly Whether this assembly contains engine modules. Used to initialize the default value for ModuleRules.bTreatAsEngineModule. Optional override for the default build settings version for modules created from this assembly. Whether the modules and targets in this assembly are installed, and should be created with the bUsePrecompiled flag set Whether to skip compiling this assembly Whether to always compile this assembly The parent rules assembly

Determines if the given path is read-only

The location to check True if the path is read-only, false otherwise

Finds all the preprocessor definitions that need to be set for the current engine.

List of preprocessor definitions that should be set

Fills a list with all the module names in this assembly (or its parent)

List to receive the module names

Fills a list with all the target names in this assembly

List to receive the target names Whether to include targets in the parent assembly

Tries to get the filename that declared the given type

True if the type was found, false otherwise

Gets the source file containing rules for the given module

The name of the module The filename containing rules for this module, or an empty string if not found

Gets the type defining rules for the given module

The name of the module The rules type for this module, or null if not found

Gets the type defining rules for the given module within this assembly

The name of the module The rules type for this module, or null if not found

Gets the source file containing rules for the given target

The name of the target The filename containing rules for this target, or an empty string if not found

Creates an instance of a module rules descriptor object for the specified module name

Name of the module Information about the target associated with this module Chain of references leading to this module Logger for output Compiled module rule info

Construct an instance of the given target rules Will return null if the requested type name does not exist in the assembly

Type name of the target rules Target configuration information to pass to the constructor Logger for output If building a low level tests target Controls validation of target and SDK Instance of the corresponding TargetRules or null if requested type name does not exist

Creates a target rules object for the specified target name.

Name of the target Platform being compiled Configuration being compiled Architectures being built Path to the project file for this target Command line arguments for this target If building a low level test target Controls validation of target and SDK Intermediate environment to use The build target rules for the specified target

Determines a target name based on the type of target we're trying to build

The type of target to look for The platform being built The configuration being built Project file for the target being built Logger for output Name of the target for the given type

Enumerates all the plugins that are available

Enumerates all the plugins that are available

Tries to find the ModuleRulesContext associated with a given module file

Class which compiles (and caches) rules assemblies for different folders.

Find all the module rules files under a given directory

The directory to search under The module context for each found rules instance Map of module files to their context

Find all the module rules files under a given directory

The directory to search under Name of the subdirectory to look under The module context for each found rules instance The UHT module type Map of module files to their context

The cached rules assembly for engine modules and targets.

Map of assembly names we've already compiled and loaded to their Assembly and list of game folders. This is used to prevent trying to recompile the same assembly when ping-ponging between different types of targets

Creates the engine rules assembly

Whether to use a precompiled engine Whether to skip compilation for this assembly Whether to always compile this assembly Logger for output New rules assembly

Creates a rules assembly

The root directories to create rules for A prefix for the assembly file name List of plugins to include in this assembly Whether the assembly should be marked as installed Whether to skip compilation for this assembly Whether to always compile this assembly The parent rules assembly Logger for output New rules assembly

Creates a rules assembly

List of plugins to include in this assembly Whether the assembly should be marked as installed Whether to skip compilation for this assembly Whether to always compile this assembly The parent rules assembly New rules assembly

Creates a rules assembly with the given parameters.

The project file to create rules for. Null for the engine. Whether to use a precompiled engine Whether to skip compilation for this assembly Whether to always compile this assembly Logger for output New rules assembly

Creates a rules assembly with the given parameters.

The plugin file to create rules for Whether to skip compilation for this assembly Whether to always compile this assembly The parent rules assembly Whether the plugin should be built as though it is a local plugin. Whether the plugin contains engine modules. Used to initialize the default value for ModuleRules.bTreatAsEngineModule. Logger for ouptut The new rules assembly

Compile a rules assembly for the current target

The project file being compiled The target being built Whether to skip compiling any rules assemblies Whether to always compile all rules assemblies Whether to use a precompiled engine build Foreign plugin to be compiled Whether the plugin should be built as though it is a local plugin Logger for output The compiled rules assembly

Finds all the module rules for plugins under the given directory.

The list of plugins to search modules for The default context for any files that are enumerated Dictionary which is filled with mappings from the module file to its corresponding context

Finds all the module and target rules for plugins' tests.

The list of plugins to search test rules for The default context for any files that are enumerated Dictionary which is filled with mappings from the module file to its corresponding context List of target files to add test target rules to

Finds all the module rules for a given plugin in a specified folder.

The plugin to search module rules for The folder relative to the plugin root to look into, usually "Source" or "Tests" The default context for any files that are enumerated Dictionary which is filled with mappings from the module file to its corresponding context

Gets the filename that declares the given type.

The type to search for. The filename that declared the given type, or null

Gets the XML comment for a particular field

The XML documentation The member to search for Logger for output Receives the description for the requested field True if a comment was found for the field

Gets the XML comment for a particular field

The XML documentation The member to search for Logger for output Receives the description for the requested field True if a comment was found for the field

Gets the XML comment for a particular field

The XML documentation The member to search for (field or property) Logger for output Receives the description for the requested member True if a comment was found for the member

Gets the XML comment for a particular field

The XML documentation The member to search for Logger for output Receives the description for the requested field True if a comment was found for the field

Represents a layer within the rules hierarchy. Any module is created within a certain scope, and may only reference modules in an equal or parent scope (eg. engine modules cannot reference project modules).

Name of this scope

The parent scope

Constructor

Name of this scope The parent scope

Checks whether this scope contains another scope

The other scope to check True if this scope contains the other scope

Formats the hierarchy of scopes

String representing the hierarchy of scopes

Scoped timer, start is in the constructor, end in Dispose. Best used with using(ScopedTimer Timer = new ScopedTimer()). Suports nesting.

Constructor

Name of the block being measured Logger for output Verbosity for output messages Whether gobal indent should be increased or not; set to false when running a scope in parallel. Message will still be printed indented relative to parent scope.

Prints out the timing message

System-wide mutex allowing only one instance of the program to run at a time

The global mutex instance

Constructor. Attempts to acquire the global mutex

Name of the mutex to acquire

Gets the name of a mutex unique for the given path

Base name of the mutex Path to identify a unique mutex

Release the mutex and dispose of the object

The header unit type markup is used for multiple things: 1. To figure out if a header can be compiled by itself or not. Many includes are included in the middle of other includes and those can never be compiled by themselves This markup is used by both msvc header unit feature and IWYU toolchain 2. Tell if the header even supports being part of a header unit. If it does not support it will also prevent all includes including it from producing a header unit This is how to markup in headers to provide above info: // HEADER_UNIT_SKIP - Here you can write why this file can't be compiled standalone // HEADER_UNIT_UNSUPPORTED - Here you can write why this file can't be part of header units.

Caches information about C++ source files; whether they contain reflection markup, what the first included header is, and so on.

Source(cpp/c) file info

Last write time of the file when the data was cached

Contents of the include directive

List of files this particular file is inlining

Header file info

Last write time of the file when the data was cached

Whether or not the file contains reflection markup

Whether or not the file has types that use DLL export/import defines

List of includes that header contains

The current file version

Location of this dependency cache

Directory for files to cache dependencies for.

The parent cache.

Map from file item to source file info

Map from file item to header file info

Map from file item to source file

Whether the cache has been modified and needs to be saved

Logger for output

Regex that matches C++ code with UObject declarations which we will need to generated code for.

Regex that matches #include UE_INLINE_GENERATED_CPP_BY_NAME(****) statements.

Regex that matches #include statements.

Regex that matches #import directives in mm files

Static cache of all constructed dependency caches

Constructs a dependency cache. This method is private; call CppDependencyCache.Create() to create a cache hierarchy for a given project.

File to store the cache Base directory for files that this cache should store data for The parent cache to use Logger for output

Returns a SourceFileInfo struct for a file (and parse the file if not already cached)

The file to parse SourceFileInfo for file

Parse the first include directive from a source file

The source file to parse The source file contents The first include directive

Read entire header file to find markup and includes

A HeaderInfo struct containing information about header

Gets the first included file from a source file

The source file to parse Text from the first include directive. Null if the file did not contain any include directives.

Finds or adds a SourceFile class for the given file

File to fetch the source file data for SourceFile instance corresponding to the given source file

Returns a list of inlined generated cpps that this source file contains.

The source file to parse List of marked files this source file contains

Determines whether the given file contains reflection markup

The source file to parse True if the file contains reflection markup

Determines whether the given file uses the *_API define

The source file to parse True if the file uses the *_API define

Returns header unit type for a header file (and parse the file if not already cached)

The header file to parse Header unit type

Returns all #includes existing inside a header file (and parse the file if not already cached)

The header file to parse List of includes

Creates a cache hierarchy for a particular target

Project file for the target being built Logger for output Dependency cache hierarchy for the given project

Enumerates all the locations of metadata caches for the given target

Project file for the target being built Dependency cache hierarchy for the given project

Reads a cache from the given location, or creates it with the given settings

File to store the cache Base directory for files that this cache should store data for The parent cache to use Reference to a dependency cache with the given settings

Save all the caches that have been modified

Reads data for this dependency cache from disk

Writes data for this dependency cache to disk

Finds mouse source files

Fills in a project file with source files discovered in the specified list of paths

Directory to search Directory base names to ignore when searching subdirectories. Can be null. True to include subdirectories, otherwise we only search the list of base directories If non-null, is updated with a list of the directories searched

Defines an interface which allows querying the working set. Files which are in the working set are excluded from unity builds, to improve iterative compile times.

Checks if the given file is part of the working set

File to check True if the file is part of the working set, false otherwise

Implementation of ISourceFileWorkingSet which does not contain any files

Dispose of the current instance.

Checks if the given file is part of the working set

File to check True if the file is part of the working set, false otherwise

Queries the working set for files tracked by Perforce.

Dispose of the current instance.

Checks if the given file is part of the working set

File to check True if the file is part of the working set, false otherwise

Queries the working set for files tracked by Git.

Constructor

Path to the Git executable Root directory to run queries from (typically the directory containing the .git folder, to ensure all subfolders can be searched) An inner working set. This allows supporting multiple Git repositories (one containing the engine, another containing the project, for example) Logger for output

Terminates the background process.

Waits for the background to terminate.

Dispose of this object

Checks if the given file is part of the working set

File to check True if the file is part of the working set, false otherwise

Parse output text from Git

Handle error output text from Git

Add a path to the working set

Path to be added

Utility class for ISourceFileWorkingSet

Sets the provider to use for determining the working set.

Sets the path to use for the repository. Interpreted relative to the Unreal Engine root directory (the folder above the Engine folder) -- if relative.

Sets the path to use for the Git executable. Defaults to "git" (assuming it is in the PATH).

Create an ISourceFileWorkingSet instance suitable for the given project or root directory

The root directory The project directories Logger for output Working set instance for the given directory

Represents an IP subnet

The prefix address

Number of bits that need to match in an IP address for this subnet

Bytes corresponding to the prefix address

Constructor

The prefix IP address Number of bits to match for this subnet

Parses a subnet from a string

The string to parse New subnet that was parsed

Checks if this subnet contains the given address

IP address to test True if the subnet contains this address

Checks if this subnet contains the given address bytes

Bytes of the IP address to text True if the subnet contains this address

Formats this subnet as text

String representation of the subnet

Attribute which can be applied to a TargetRules-dervied class to indicate which configurations it supports

Array of supported platforms

Initialize the attribute with a list of configurations

Variable-length array of configuration arguments

Attribute which can be applied to a TargetRules-dervied class to indicate which platforms it supports

Initialize the attribute with a list of platform groups

Variable-length array of platform group arguments

Attribute which can be applied to a TargetRules-dervied class to indicate which platforms it supports

Array of supported platforms

Initialize the attribute with a list of platforms

Variable-length array of platform arguments

Initialize the attribute with all the platforms in a given category

Category of platforms to add

Attribute which can be applied to a TargetRules-dervied class to indicate which target types it supports

Array of supported target types

Initialize the attribute with a list of target types

Variable-length array of target type arguments

Hash of all the gen.cpp files being inlined in this source file

Helper function to calculate a hash for the passed in inline gen.cpp file names

Gen.cpp file names Hash of file names

Cached list of actions that need to be executed to build a target, along with the information needed to determine whether they are valid.

The version number to write

The time at which the makefile was created

The time at which the makefile was modified

Additional diagnostic output to print before building this target (toolchain version, etc...)

Any additional information about the build environment which the platform can use to invalidate the makefile

The main executable output by this target

Path to the receipt file for this target

The project intermediate directory

The project intermediate directory without architecture info

Type of the target

Is test target?

Map of config file keys to values. Makefile will be invalidated if any of these change.

Whether the target should be deployed after being built

Collection of all located UBT C# plugins regardless of if they are in an enabled plugin (project file)

Collection of UBT C# plugins contained in enabled plugins (project file)

Collection of UHT C# plugins contained in enabled plugins (target assembly file)

The array of command-line arguments. The makefile will be invalidated whenever these change.

The array of command-line arguments passed to UnrealHeaderTool.

Scripts which should be run before building anything

Targets which should be build before building anything

Every action in the action graph

Environment variables that we'll need in order to invoke the platform's compiler and linker

The final output items for all target

Maps module names to output items

List of game module names, for hot-reload

List of all source directories

Set of all source directories. Any files being added or removed from these directories will invalidate the makefile.

Set of all known header files, changes will not invalidate the makefile but are used to determine if a header is included in the target.

The set of source files that UnrealBuildTool determined to be part of the programmer's "working set". Used for adaptive non-unity builds.

Set of files which are currently not part of the working set, but could be.

Maps each target to a list of UObject module info structures

Used to map names of modules to their .Build.cs filename

All build modules containing Verse code

If Verse should use the BPVM backend

List of config settings in generated config files

List of all plugin names. The makefile will be considered invalid if any of these changes, or new plugins are added.

Set of external (ie. user-owned) files which will cause the makefile to be invalidated if modified after

Set of internal (eg. response files, unity files) which will cause the makefile to be invalidated if modified.

TargetRules-set memory estimate per action. Used to control the number of parallel actions that are spawned.

Enumerable of all source and header files tracked by this makefile.

Constructor

External build metadata from the platform Path to the executable or primary output binary for this target Path to the receipt file Path to the project intermediate directory Path to the project intermediate directory The type of target Set of dependencies on config files Whether to deploy the target after compiling Collection of UBT plugins Collection of UBT plugins Collection of UBT plugins for UHT

Constructor. Reads a makefile from disk.

The archive to read from Last modified time for the makefile

Write the makefile to the given archive

The archive to write to

Saves a makefile to disk

Path to save the makefile to

Loads a makefile from disk

Path to the makefile to load Path to the project file Platform for this makefile Command line arguments for this target Logger for output If the function returns null, this string will contain the reason why The loaded makefile, or null if it failed for some reason. On failure, the 'ReasonNotLoaded' variable will contain information about why

Checks if the makefile is valid for the current set of source files. This is done separately to the Load() method to allow pre-build steps to modify source files.

The makefile that has been loaded Path to the project file The platform being built The current working set of source files Logger for output diagnostics If the makefile is not valid, is set to a message describing why True if the makefile is valid, false otherwise

Determines if a directory, or any subdirectory of it, contains new source files or headers

Directory to search through Set of directory names to exclude Logger for output diagnostics True if the directory contains any source files

Finds all the source files under a directory that contain reflection markup

The directory to search Cache of source file metadata Set of folder names to ignore when recursing the directory tree Receives the set of files which contain reflection markup Queue to add sub-tasks to

Gets the location of the makefile for particular target

Project file for the build Name of the target being built The platform that the target is being built for The architectures the target is being built for (can be blank to signify a default) The configuration being built Intermediate environment to use Path to the makefile

Type of a build product

An executable file

A dynamically loaded module.

A symbol file. Not required for the executable to run.

A map file. Not required for the executable to run.

A resource file which was generated by the build and is required for the executable to run.

A build resource which was generated by the build, but is not required for the executable to run.

A package which can be deployed on device (eg. *.apk for Android, *.stub for iOS)

A file that was created as part of the build process

Path to the file.

Type of the build product.

Private constructor, for serialization.

Constructor.

Path to the build product Type of the build product

Copy constructor.

Build product to copy settings from

Convert this object to a string, for debugging.

Path to this build product

How a file may be staged

Only accessed through Unreal filesystem functions; may be included in a PAK file.

Must be kept as part of the loose filesystem.

Debug file which must be kept as part of the loose filesystem.

System file which must be kept as part of the loose filesystem. System files are not subject to being automatic remapping or renaming by the platform layer.

Information about a file which is required by the target at runtime, and must be moved around with it.

The file that should be staged. Should use $(EngineDir) and $(ProjectDir) variables as a root, so that the target can be relocated to different machines.

How to stage this file.

Private constructor, for serialization.

Constructor

Path to the runtime dependency How to stage the given path

Copy constructor

Runtime dependency to copy settings from

Convert this object to a string for debugging

String representation of the object

List of runtime dependencies, with convenience methods for adding new items

Default constructor

Copy constructor

Sequence of runtime dependencies to initialize with

Add a runtime dependency to the list

Path to the runtime dependency. May include wildcards. How to stage this file

Arbitrary property name/value which metadata from the build scripts can be passed on to downstream tasks

Property name

Value of the property

Construct a property with the given name and value

Name of the property Value of the property

Stores a record of a built target, with all metadata that other tools may need to know about the build.

Path to the project file for this target

The project directory

The name of this target

Which platform the target is compiled for

Which platform the target is compiled for

Which configuration this target is compiled in

The type of the target

Whether it's a low level tests target

Version information for this target.

The exectuable to launch for this target

The console subsystem/commmandlet exectuable to launch for this target

The build products which are part of this target

All the runtime dependencies that this target relies on

All plugins that were either enabled or disabled via the target rules.

All plugins that were built via the target rules.

Additional build properties passed through from the module rules

Constructor

Path to the project file for this target The name of the target being compiled The type of target Platform for the target being compiled Configuration of the target being compiled Version information for the target Architecture information for the target Whether it's a target for low level tests

Adds a build product to the receipt. Does not check whether it already exists.

Path to the build product. Type of build product. The BuildProduct object that was created

Merges another receipt to this one.

Receipt which should be merged

Inserts variables to make a file relative to $(EngineDir) or $(ProjectDir)

The file to insert variables into. Value of the $(EngineDir) variable. Value of the $(ProjectDir) variable. Converted path for the file.

Inserts variables to make a file relative to $(EngineDir) or $(ProjectDir)

The path to insert variables into. Value of the $(EngineDir) variable. Value of the $(ProjectDir) variable. Converted path for the file.

Returns the standard path to the build receipt for a given target

Base directory for the target being built; either the project directory or engine directory. The target being built The target platform The target configuration The architecture being built Path to the receipt for this target

Determine whether a BuildProduct Type is NonUFS or DebugNonUFS

The build product to check

Checks the Additional properties for one with the given name that matches the given value

Property name to search for Value to compare against (with StringComparison.InvariantCultureIgnoreCase) True if any property with PropertyName has a value matching Value

Read a receipt from disk.

Filename to read from

Read a receipt from disk.

Filename to read from Engine directory for expanded variables

Try to read a receipt from disk, failing gracefully if it can't be read.

Filename to read from If successful, the receipt that was read True if successful

Try to read a receipt from disk, failing gracefully if it can't be read.

Filename to read from Engine directory for expanded paths If successful, the receipt that was read True if successful

Write the receipt to disk.

Output filename

Write the receipt to disk.

Output filename Engine directory for expanded paths

Telemetry service for UnrealBuildTool

Dispose

Public interface for a timeline scope. Should be disposed to exit the scope.

Tracks simple high-level timing data

A marker in the timeline

Name of the marker

Time at which the event ocurred

Time at which the event ended

The trace span for external tracing

Constructor

Event name Time of the event Finish time for the event. May be null.

Finishes the current event

Disposes of the current event

The stopwatch used for timing

The recorded events

Property for the total time elapsed

Start the stopwatch

Records a timeline marker with the given name

The marker name

Enters a scope event with the given name. Should be disposed to terminate the scope.

Name of the event Event to track the length of the event

Prints this information to the log

Updates the last event time

Prints an individual event to the log

Start time for the event Finish time for the event. May be null. Event name List of all the start times for parent events Verbosity for the output Logger for output

Formats a timespan in milliseconds

The time to format Formatted timespan

Types of timing data events.

No type assigned.

This event represents an aggregate of summary events.

This event represents a summary of related include, class, and function events, usually summarizing a single compilation unit or part of a compilation unit.

Timing related to compiling include files.

Timing related to compiling classes.

Timing related to compiling functions.

Class used to capture timing data from events like those generated by MSVC when timing data is being generated.

Constructs a new instance of .

Constructs a new instance of using data from a .

The to get the data from.

The name of the event being represented, such as a file or category name.

The type of timing data this event represents.

Gets the number of times this event was encountered.

Gets the amount of time, in milliseconds, that the event took to complete disregarding its sub-events.

Gets the amount of time, in milliseconds, that the event took including its sub-events.

If this event is a sub-event, the parent is the event it is the sub-event to.

Any sub-events of this event.

Adds a sub-event (child) to this event if it doesn't exist, or increase the duration by the duration of the provided event.

The sub-event to add to this event.

Creates a deep clone of this event.

A deep clone of this event.

Writes a binary representation of this event and its sub-events.

The to write the binary representation to.

Systems that need to be configured to execute a tool mode

Do not initialize anything

Start prefetching metadata for the engine folder as early as possible

Initializes the XmlConfig system

Registers build platforms

Registers build platforms

Registers build platforms for validation

Only allow a single instance running in the branch at once

Print out the total time taken to execute

Capture logs as early as possible in a StartupTraceListener object

Attribute used to specify options for a UBT mode.

Name of this mode

Options for executing this mode

Constructor

Name of the mode Options for this mode

Base class for standalone UBT modes. Different modes can be invoked using the -Mode=[Name] argument on the command line, where [Name] is determined by the ToolModeAttribute on a ToolMode derived class. The log system will be initialized before calling the mode, but little else.

Entry point for this command.

List of command line arguments Exit code for the process

Helper class implementing the standard topological sorting algorithm for directed graphs. It generates a flattened sequence of nodes in the order that respects all the given dependencies between nodes (edges). So, if we have edges A -> B and B -> C, A will be always before B and C, and B will be before C. In many cases there are more than one possible solutions. This helper just generates one of them. The algorithm only works for directed acyclic graphs, as otherwise it's impossible to order the nodes. In this implementation we can choose how cycles should be handled (CycleHandling member). By default sorting fails, but we may set the class to arbitrarily break cycles and complete the task.

Type of node objects

Enumeration indicating how graph cycles should be handled.

Fail sorting on the first cycle encountered (the algorithmically correct solution).

Break cycles at the point they are detected (allows the algorithm to always complete but may skip some edges).

Break cycles at the point they are detected (same as Break but outputs warning logs with information about the cycles).

Determines what should be done when a cycle in the graph is encountered.

UBT's logger object. Necessary if we want to get diagnostics, especially when BreakWithInfo is used.

Functor returning a node's name. Necessary for some logging diagnostics, especially when BreakWithInfo is used.

List of all graph nodes (each user-provided node T is wrapped in an internal GraphNode).

When traversing the graph, it represents all the nodes visited in the current sequence. For instance, if we go from node A to K and then X, Callstack will store A, K, X. It's only needed for diagnostic purposes i.e. when we find a cycle we use Callstack to output all the cycle's nodes.

The resulting sequence of nodes (T, provided by the user) in the topological order.

Initialize the sorter object and create the internal graph representation. The list of all the graph nodes doesn't need to be provided because it's internally generated from Edges (union of all edges' Item1 and Item2.

List of connections between nodes

Sort the graph to generate a flat sequence of nodes respecting all graph dependencies.

True on success, false if failed (most likely a cycle encountered)

Get the list of sorted nodes (valid after successfully calling Sort).

Process a single node.

True on success, false if failed (most likely a cycle encountered)

Create the internal graph structure for the provided list of edges.

List of tuples representing connections between nodes

Clear the state (in-progress, done) of all graph nodes.

Member executed when a graph cycle is encountered.

True if operation should continue, false if a cycle is considered an error

Returns all nodes being part of a cycle (call valid only if we've really detected a cycle).

Returns a string with a list of names of nodes forming a graph cycle (call valid only if we've really detected a cycle).

Graph node's state wrt the traversal.

Internal helper representing a graph node (wrapping the user-provided node and storing internal state).

User-provided node object.

List of graph nodes we can visit starting from this one.

Traversal state (in-progress, done).

Maps a unique string to an integer

Default constructor

See if string is in registry

True if string is present in registry

Add string if missing and/or lookup

String instance id

Get list of strings

String list

Get list of string ids

String id list

Get string given instance id

String

See if alias exists in registry

True if alias exists

Get instance id of alias

Instance id of alias

Add alias if missing and/or lookup

Instance id of alias

Prefix used for all dynamically created Unity modules

A class which represents a list of files and the sum of their lengths.

The length of this file collection, plus any additional virtual space needed for bUseAdapativeUnityBuild. See the comment above AddVirtualFile() below for more information.

Doesn't actually add a file, but instead reserves space. This is used with "bUseAdaptiveUnityBuild", to prevent other compiled unity blobs in the module's numbered set from having to be recompiled after we eject source files one of that module's unity blobs. Basically, it can prevent dozens of files from being recompiled after the first time building after your working set of source files changes

The virtual file to add to the collection

A class for building up a set of unity files. You add files one-by-one using AddFile then call EndCurrentUnityFile to finish that one and (perhaps) begin a new one.

Constructs a new UnityFileBuilder.

The accumulated length at which to automatically split a unity file, or -1 to disable automatic splitting.

Adds a file to the current unity file. If splitting is required and the total size of the unity file exceeds the split limit, then a new file is automatically started.

The file to add.

Doesn't actually add a file, but instead reserves space, then splits the unity blob normally as if it was a real file that was added. See the comment above FileCollection.AddVirtualFile() for more info.

The file to add virtually. Only the size of the file is tracked.

Starts a new unity file. If the current unity file contains no files, this function has no effect, i.e. you will not get an empty unity file.

Returns the list of built unity files. The UnityFileBuilder is unusable after this.

Given a set of C++ files, generates another set of C++ files that #include all the original files, the goal being to compile the same code in fewer translation units. The "unity" files are written to the IntermediateDirectory.

The target we're building The C++ files to #include. The header files that might correspond to the C++ files. The environment that is used to compile the C++ files. Interface to query files which belong to the working set Base name to use for the Unity files Intermediate directory for unity cpp files The makefile being built Receives a mapping of source file to unity file Receives the files to compile using the normal configuration. Receives the files to compile using the adaptive unity configuration. An approximate number of bytes of C++ code to target for inclusion in a single unified C++ file. The merged XML program to run XML namespace Trace flag to enable debugging Project file reference Variable state Local context trace

Equivalent of FConfigCacheIni_UPL. Parses ini files. This version reads ALL sections since ConfigCacheIni_UPL does NOT

Exception when parsing ini files

command class for being able to create config caches over and over without needing to read the ini files

List of values (or a single value)

Ini section (map of keys and values)

True if we are loading a hierarchy of config files that should be merged together

All sections parsed from ini file

Constructor. Parses a single ini file. No Platform settings, no engine hierarchy. Do not use this with ini files that have hierarchy!

The ini file to load

Constructor. Parses ini hierarchy for the specified project. No Platform settings.

Ini name (Engine, Editor, etc) Project path Logger for

Constructor. Parses ini hierarchy for the specified project. No Platform settings.

Ini name (Engine, Editor, etc) Project path Logger for output

Constructor. Parses ini hierarchy for the specified platform and project.

Project path Target platform Ini name (Engine, Editor, etc)

Constructor. Parses ini hierarchy for the specified platform and project.

Project path Target platform Ini name (Engine, Editor, etc)

Finds a section in INI

Found section or null

Finds values associated with the specified key (does not copy the list)

Gets all values associated with the specified key

Section where the key is located Key name Copy of the list containing all values associated with the specified key True if the key exists

Gets a single string value associated with the specified key.

Section name Key name Value associated with the specified key. If the key has more than one value, only the first one is returned True if the key exists

Gets a single bool value associated with the specified key.

Section name Key name Value associated with the specified key. If the key has more than one value, only the first one is returned True if the key exists

Gets a single Int32 value associated with the specified key.

Section name Key name Value associated with the specified key. If the key has more than one value, only the first one is returned True if the key exists

Gets a single GUID value associated with the specified key.

Section name Key name Value associated with the specified key. If the key has more than one value, only the first one is returned True if the key exists

Gets a single float value associated with the specified key.

Section name Key name Value associated with the specified key. If the key has more than one value, only the first one is returned True if the key exists

Gets a single double value associated with the specified key.

Section name Key name Value associated with the specified key. If the key has more than one value, only the first one is returned True if the key exists

List of actions that can be performed on a single line from ini file

Checks what action should be performed on a single line from ini file

Loads and parses ini file.

Splits a line into key and value

Processes parsed key/value pair

Finds an existing section or adds a new one

Returns a list of INI filenames for the engine

Returns a list of INI filenames for the given project

Returns the platform name to use as part of platform-specific config files

Utility functions

Searches for a flag in a set of command-line arguments.

Regular expression to match $(ENV) and/ or %ENV% environment variables.

Resolves $(ENV) and/ or %ENV% to the value of the environment variable in the passed in string.

String to resolve environment variable in. String with environment variable expanded/ resolved.

Expands variables in $(VarName) format in the given string. Variables are retrieved from the given dictionary, or through the environment of the current process. Any unknown variables are ignored.

String to search for variable names Lookup of variable names to values If true, then Environment.GetEnvironmentVariable will not be used if the var is not found in AdditionalVariables String with all variables replaced

Makes sure path can be used as a command line param (adds quotes if it contains spaces)

Path to convert

Makes sure path can be used as a command line param (adds quotes if it contains spaces)

Path to convert

Escapes whitespace in the given command line argument with a backslash. Used on Unix-like platforms for command line arguments in shell commands.

The argument to escape Escaped shell argument

This is a faster replacement of File.ReadAllText. Code snippet based on code and analysis by Sam Allen http://dotnetperls.com/Content/File-Handling.aspx

Source file to fully read and convert to string Textual representation of file.

Reads the specified environment variable

the environment variable to read the default value to use if missing the value of the environment variable if found and the default value if missing

Reads the specified environment variable

the environment variable to read the default value to use if missing the value of the environment variable if found and the default value if missing

Reads the specified environment variable

the environment variable to read the default value to use if missing the value of the environment variable if found and the default value if missing

Reads the specified environment variable

the environment variable to read the default value to use if missing the value of the environment variable if found and the default value if missing

Try to launch a local process, and produce a friendly error message if it fails.

Runs a local process and pipes the output to the log

Output a line of text from a local process. Implemented as a separate function to give a useful function name in the UAT log prefix.

Runs a local process and pipes the output to a file

Runs a local process and pipes the output to the log

Runs a command line process, and returns simple StdOut output. This doesn't handle errors or return codes

The entire StdOut generated from the process as a single trimmed string Command to run Arguments to Command

Runs a command line process, and returns simple StdOut output. This doesn't handle errors or return codes

The entire StdOut generated from the process as a single trimmed string Command to run Arguments to Command Logger for output

Runs a command line process, and returns simple StdOut output.

The entire StdOut generated from the process as a single trimmed string Command to run Arguments to Command The return code from the process after it exits

Runs a command line process, and returns simple StdOut output.

The entire StdOut generated from the process as a single trimmed string Command to run Arguments to Command The return code from the process after it exits Whether to also log standard output and standard error

Runs a command line process, and returns simple StdOut output.

The entire StdOut generated from the process as a single trimmed string Command to run Arguments to Command Logger for output. No output if null. The return code from the process after it exits

Find all the platforms in a given class

Class of platforms to return Array of platforms in the given class

Retrieve the list of platforms in this group (if any)

Given a list of supported platforms, returns a list of names of platforms that should not be supported

List of supported platforms If true, add platforms that are present but not available for compiling List of unsupported platforms in string format

Takes a path string and makes all of the path separator characters consistent. Also removes unnecessary multiple separators.

File path with potentially inconsistent slashes The directory separator to use File path with consistent separators

Correctly collapses any ../ or ./ entries in a path.

The path to be collapsed true if the path could be collapsed, false otherwise.

Given a file path and a directory, returns a file path that is relative to the specified directory

File path to convert The directory that the source file path should be converted to be relative to. If this path is not rooted, it will be assumed to be relative to the current working directory. True if we should treat the source path like a directory even if it doesn't end with a path separator Converted relative path

Backspaces the specified number of characters, then displays a progress percentage value to the console

Progress numerator Progress denominator Number of characters to backspace before writing the text. This value will be updated with the length of the new progress string. The first time progress is displayed, you should pass 0 for this value.

Reads a class using XML serialization

The type to read The XML file to read from Logger for output New deserialized instance of type T

Serialize an object to an XML file

Type of the object to serialize Object to write File to write to Default namespace for the output elements Logger for output True if the file was written successfully

Returns true if the specified Process has been created, started and remains valid (i.e. running).

Process object to test True if valid, false otherwise.

Removes multi-dot extensions from a filename (i.e. *.automation.csproj)

Filename to remove the extensions from Clean filename.

Returns Filename with path but without extension.

Filename Path to the file with its extension removed.

Returns true if the specified file's path is located under the specified directory, or any of that directory's sub-folders. Does not care whether the file or directory exist or not. This is a simple string-based check.

The path to the file The directory to check to see if the file is located under (or any of this directory's subfolders)

Checks if given type implements given interface.

Interface to check. Type to check. True if TestType implements InterfaceType. False otherwise.

Returns the User Settings Directory path. This matches FPlatformProcess::UserSettingsDir(). NOTE: This function may return null. Some accounts (eg. the SYSTEM account on Windows) do not have a personal folder, and Jenkins runs using this account by default.

Gets the number of logical cores. We use this rather than Environment.ProcessorCount when possible to handle machines with > 64 cores (the single group limit available to the .NET framework).

The number of logical cores.

Gets the number of physical cores, excluding hyper threading.

The number of physical cores, or -1 if it could not be obtained

Gets if the processos has asymmetrical cores (Windows only)

Gets the total memory bytes available, based on what is known to the garbage collector.

This will return a max of 2GB for a 32bit application. The total memory available, in bytes.

Gets the total system memory in bytes based on what is known to the garbage collector.

This will return a max of 2GB for a 32bit application. The total system memory free, in bytes.

Gets the total memory bytes free, based on what is known to the garbage collector.

This will return a max of 2GB for a 32bit application. The total memory free, in bytes.

Gives the current CPU utilization.

Percentage of CPU utilization currently. Whether or not it was successful in getting the CPU utilization.

Determines the maximum number of actions to execute in parallel, taking into account the resources available on this machine.

How many actions to execute in parallel. When 0 a default will be chosen based on system resources Physical processor count multiplier for local execution. Can be below 1 to reserve CPU for other tasks. Consider logical cores when determing max actions to execute in parallel. Unused if ProcessorCountMultiplier is not 1.0. Limit max number of actions based on total system memory. Max number of actions to execute in parallel

Executes a list of custom build step scripts

List of script files to execute Logger for output True if the steps succeeded, false otherwise

Parses a command line into a list of arguments

The command line to parse List of output arguments

Formats a list of arguments as a command line, inserting quotes as necessary

List of arguments to format Command line string

Writes a file if the contents have changed

Location of the file New contents of the file Logger for output

Writes a file if the contents have changed

Location of the file New contents of the file The type of string comparison to use Logger for output

Writes a file if the contents have changed

Location of the file New contents of the file Logger for output

Writes a file if the contents have changed

Location of the file New contents of the file The type of string comparison to use Logger for output

Record each file that has been requested written, with the number of times the file has been written

Writes a file if the contents have changed

Location of the file New contents of the file Logger for output

Writes a file if the contents have changed

Location of the file New contents of the file The type of string comparison to use Logger for output

Writes a file if the contents have changed

Location of the file New contents of the file Logger for output

Writes a file if the contents have changed

Location of the file New contents of the file The type of string comparison to use Logger for output

Determines the appropriate encoding for a string: either ASCII or UTF-8. If the string length is equivalent to the encoded length, then no non-ASCII characters were present in the string. Don't write BOM as it messes with clang when loading response files.

The string to test. Either System.Text.Encoding.ASCII or System.Text.Encoding.UTF8, depending on whether or not the string contains non-ASCII characters.

Determines the appropriate encoding for a list of strings: either ASCII or UTF-8. If the string length is equivalent to the encoded length, then no non-ASCII characters were present in the string. Don't write BOM as it messes with clang when loading response files.

The string to test. Either System.Text.Encoding.ASCII or System.Text.Encoding.UTF8, depending on whether or not the strings contains non-ASCII characters.

Attempts to create a symbolic link at location specified by Path pointing to location specified by PathToTarget. Soft symlinks are available since Windows 10 build 14972 without elevated privileges if developer mode is enabled. Hard links are available since Windows 8 for NTFS/NFS file systems.

Path to create the symbolic link at. Path to which the symbolic link should point to. Logger for output. True if symlink was created, false if failed.

If this is an immediate operand, the value will be embedded in the opcode itself. This should be set to the the string name of the underlying operand native type.

Generates bytecode and bytecode helpers for the VerseVM.

Entrypoint to generate the bytecode. Generated code will go in Directory.

Functions for manipulating the XML config cache

An input config file

Location of the file

Which folder to display the config file under in the generated project files

Constructor

The cache file that is being used

Parsed config values

Cached serializer for the XML schema

Initialize the config system with the given types

Force use of the cached XML config without checking if it's valid (useful for remote builds) Read XML configuration with a Project directory Logger for output

Find all the configurable types in the current assembly

List of configurable types

Determines whether the given type has a field with an XmlConfigFile attribute

The type to check True if the type has a field with the XmlConfigFile attribute

Find the location of the XML config schema

Optional project root directory The location of the schema file

Initialize the list of input files

Create a default config file at the given location

Location to read from

Applies config values to the given object

The object instance to be configured

Instances a value for assignment to a target object

The value to instance The type of value New instance of the given value, if necessary

Gets a config value for a single value, without writing it to an instance of that class

Type to find config values for Name of the field to receive On success, receives the value of the field True if the value was read, false otherwise

Find all the configurable fields in the given types by searching for XmlConfigFile attributes.

Array of types to search Dictionaries populated with category -> name -> field mappings on return

Creates a schema from attributes in the given types

Lookup for all field settings New schema instance

Creates an XML schema element for reading a value of the given type

Name of the field Type of the field New schema element representing the field

Writes a schema to the given location. Avoids writing it if the file is identical.

The schema to be written Location to write to

Tests whether a type is a nullable struct, and extracts the inner type if it is

Reads an XML config file and merges it to the given cache

Location to read from Lookup for configurable fields by category Map of types to fields and their associated values Schema to validate against Logger for output True if the file was read successfully

Parse the value for a field from its text based representation in an XML file

The type of field being read Text to parse The object that was parsed

Checks that the given cache file exists and is newer than the given input files, and attempts to read it. Verifies that the resulting cache was created from the same input files in the same order.

Path to the config cache file The expected set of input files in the cache True if the cache was valid and could be read, false otherwise.

Generates documentation files for the available settings, by merging the XML documentation from the compiler.

The documentation file to write Logger for output

Writes out documentation in UDN format

The output file The XML documentation for this assembly Map of string to types to fields Logger for output

Writes out documentation in HTML format

The output file The XML documentation for this assembly Map of string to types to fields Logger for output

Stores parsed values from XML config files which can be applied to a configurable type. Can be serialized to disk in binary form as a cache.

The current cache serialization version

List of input files. Stored to allow checking cache validity.

Abstract description of a target data member.

Returns Reflection.MemberInfo describing the target class member.

Returns Reflection.Type of the target class member.

Indicates whether the target class member is static or not.

Returns the value setter of the target class member.

Returns the value getter of the target class member.

Description of a field member.

Description of a property member.

Stores a mapping from type -> member -> value, with all the config values for configurable fields.

Constructor

Attempts to read a previous block of config values from disk

The file to read from Array of valid types. Used to resolve serialized type names to concrete types. On success, receives the parsed data True if the data was read and is valid

Find a data member (field or property) with the given name and attribute and returns TargetMember wrapper created for it.

Attribute a member has to have to be considered. Type which members are to be searched Name of a member (field or property) to find. TargetMember wrapper or null if no member has been found.

Writes the coalesced config hierarchy to disk

File to write to

Implementation of XmlDocument which preserves line numbers for its elements

Root element for the XML document

Namespace for the XML schema

The file being read

Interface to the LineInfo on the active XmlReader

Set to true if the reader encounters an error

Private constructor. Use XmlConfigFile.TryRead to read an XML config file.

Overrides XmlDocument.CreateElement() to construct ScriptElements rather than XmlElements

Loads a script document from the given file

The file to load The schema to validate against Logger for output If successful, the document that was read True if the document could be read, false otherwise

Callback for validation errors in the document

Standard argument for ValidationEventHandler Standard argument for ValidationEventHandler

Implementation of XmlElement which preserves line numbers

The file containing this element

The line number containing this element

Constructor

Marks a field as being serializable from a config file

The category for this config value. Optional; defaults to the declaring type name.

Name of the key to read. Optional; defaults to the field name.

Use this field to indicate that the XML attribute has been deprecated, and that a warning should be shown to the user if it is used. A deprecated field should also be marked with the [Obsolete] attribute.

If the attribute has been deprecated because it has been renamed, this field can be used to apply the value used for this field to another.

Helper class for managing Xcode paths, versions, etc. Helps to differentiate between Apple xcode platforms

Which developer directory to root from? If this is "xcode-select", UBT will query for the currently selected Xcode

Directory for the developer binaries

A portion of the target "tuple"

The version of the iOS SDK to target at build time.

The version in a floating point value for easy comparison

Cache SDK dir for device and simulator (for non-Mac)

Constructor, called by platform sybclasses

SDK name (like "MacOSX") Sinulator SDK name (like "iPhoneOSSimulator") Platform name used in the -target parameter

Get the path to the SDK diretory in xcode for the given architecture

Gets the string used by xcode to taget a platform and version (will return something like "arm64-apple-ios17.0-simulator"

Find the Xcode developer directory

Takes an architecture string as provided by UBT for the target and formats it for Clang. Supports multiple architectures joined with '+'

Writes a versions.xcconfig file for xcode to pull in when making an app plist

FileItem describing the Prerequisite that this will this depends on (executable or similar) List of actions to be executed. Additional actions will be added to this list.

If the project is a UnrealGame project, Target.ProjectDirectory refers to the engine dir, not the actual dir of the project. So this method gets the actual directory of the project whether it is a UnrealGame project or not.

The actual project directory. The path to the project file

Genearate an run-only Xcode project, that is not meant to be used for anything else besides code-signing/running/etc of the native .app bundle

Location of .uproject file (or null for the engine project The platform to generate a project for The name of the target being built, so we can generate a more minimal project True if this is making a bild for uploading to app store Logging object Returns the .xcworkspace that was made

Single

Common option flags for the Clang toolchains. Usage of these flags is currently inconsistent between various toolchains.

No custom options

Enable address sanitzier

Enable hardware address sanitzier

Enable thread sanitizer

Enable undefined behavior sanitizer

Enable minimal undefined behavior sanitizer

Enable memory sanitizer

Enable Shared library for the Sanitizers otherwise defaults to Statically linked

Enables link time optimization (LTO). Link times will significantly increase.

Enable thin LTO

Enable tuning of debug info for LLDB

Whether or not to preserve the portable symbol file produced by dump_syms

(Apple toolchains) Whether we're outputting a dylib instead of an executable

Enables the creation of custom symbol files used for runtime symbol resolution.

Enables dead code/data stripping and common code folding.

Indicates that the target is a moduler build i.e. Target.LinkType == TargetLinkType.Modular

Disable Dump Syms step for faster iteration

Indicates that the AutoRTFM Clang compiler should be used instead of the standard clang compiler

Enable LibFuzzer

Modify code generation to help with debugging optimized builds e.g. by extending lifetimes of local variables. It may slightly reduce performance. Thus, it's meant to be used during development only. Supported only on some platforms.

Enables compressing the debug sections if the platform supports this

Constructor for ClangToolChainInfo

The base path to the clang sdk root, if available The path to the compiler The path to the archiver Logging interface

Lazily query the clang version. Will only be executed once.

The version of clang

Lazily query the clang version output. Will only be executed once.

The standard output when running Clang --version

Lazily query the archiver version output. Will only be executed once.

The standard output when running Archiver --version

Sanitizes a preprocessor definition argument if needed.

A string in the format "foo=bar" or "foo". An escaped string

Checks if compiler version matches the requirements

Checks if compiler version matches the requirements

Common compile arguments that control which warnings are enabled. https://clang.llvm.org/docs/DiagnosticsReference.html

Compile arguments for FP semantics

Compile arguments for optimization settings, such as profile guided optimization and link time optimization

Compile arguments for debug settings

Compile arguments for sanitizers

Additional compile arguments.

Compile arguments for running clang-analyze.

Common compile arguments for all files in a module. Override and call base.GetCompileArguments_Global() in derived classes.

Compile arguments for specific files in a module. Also updates Action and CPPOutput results.

Path to the target file (such as .o)

Used by other tools to get the extra arguments to run vanilla clang for a particular platform.

List of extra arguments to add to.

Get CPU Instruction set targets for ISPC.

Which OS platform to target. Which architecture inside an OS platform to target. Only used for Android currently. List of instruction set targets passed to ISPC compiler

Get OS target for ISPC.

Which OS platform to target. OS string passed to ISPC compiler

Get CPU architecture target for ISPC.

Which OS platform to target. Which architecture inside an OS platform to target. Only used for Android currently. Arch string passed to ISPC compiler

Get CPU target for ISPC.

Which OS platform to target. CPU string passed to ISPC compiler

Get host compiler path for ISPC.

Which OS build platform is running on. Path to ISPC compiler

Get the host bytecode-to-obj compiler path for ISPC. Only used for platforms that support compiling ISPC to LLVM bytecode

Which OS build platform is running on. Path to bytecode to obj compiler

Returns the version of the ISPC compiler for the specified platform. If GetISPCHostCompilerPath() doesn't return a valid path this will return a -1 version.

Which OS build platform is running on. Version reported by the ISPC compiler

Get object file format for ISPC.

Which OS build platform is running on. Object file suffix

Get object file suffix for ISPC.

Which OS build platform is running on. Object file suffix

Normalize a path for use in a command line, making it relative to Engine/Source if under the root directory

The FileSystemReference to normalize Normalized path as a string

Normalize a path for use in a command line, making it relative if under the Root Directory

The FileItem to normalize Normalized path as a string

Stores information about how a local directory maps to a remote directory

Handles uploading and building on a remote Mac

These two variables will be loaded from the XML config file in XmlConfigLoader.Init().

The remote username.

If set, instead of looking for RemoteToolChainPrivate.key in the usual places (Documents/Unreal, Engine/UnrealBuildTool/SSHKeys or Engine/Build/SSHKeys), this private key will be used.

The authentication used for Rsync (for the -e rsync flag).

The authentication used for SSH (probably similar to RsyncAuthentication).

Save the specified port so that RemoteServerName is the machine address only

Path to Rsync

Path to SSH

The project being built. Settings will be read from config files in this project.

The project descriptor for the project being built.

A set of directories containing additional paths to be built.

The base directory on the remote machine

Mappings from local directories to remote directories

Arguments that are used by every Ssh call

Arguments that are used by every Rsync call

Arguments that are used by directory Rsync call

Constructor

Project to read settings from Logger for output Is the primary Remote Mac or not. True by default. Added arguments when preparing a secondary Mac for debug. False by default.

Attempts to get the SSH private key from the standard locations

If successful, receives the location of the private key that was found True if a private key was found, false otherwise

Expand all the variables in the given string

The input string String with any variables expanded

Flush the remote machine, removing all existing files

Returns true if the remote executor supports this target platform

The platform to check True if the remote mac handles this target platform

Clean a target remotely

Descriptor for the target to build Logger for diagnostic output True if the build succeeded, false otherwise

Build a target remotely

Descriptor for the target to build Path to store the remote log file If true then any PreBuildTargets will be skipped Logger for diagnostic output True if the build succeeded, false otherwise

Creates a temporary directory for the given target

The target descriptor Directory to use for temporary files

Translate the arguments for a target descriptor for the remote machine

The target descriptor Manifest files to be output from this target List of remote arguments

Runs the actool utility on a directory to create an Assets.car file

The target platform Input directory containing assets Path to the Assets.car file to produce Logger for output

Prepare the remotely built iOS or tvOS client to de debugged on Mac

Where the content has been previously cooked The project file The logger

Retrieves data from the primary Mac to the Windows machine

The project file The logger The platfrom for the client (typically iOS or tvOS)

Upload retrieved data from the primary Mac from the Windows machine to the secondary Mac

The project file The logger

Convers a remote path into local form

The remote filename Local filename corresponding to the remote path

Converts a local path into a remote one

The local path to convert Equivalent remote path

Converts a local path into a remote one

The local path to convert Equivalent remote path

Gets the local path in Cygwin format (eg. /cygdrive/C/...)

Local path Path in cygwin format

Escapes spaces and brackets in a shell command argument

The argument to escape The escaped argument

Upload a single file to the remote

The file to upload Logger for output

Upload a single file to the remote

The base directory to copy The remote directory The file to upload Logger for output

Upload a single directory to the remote

The local directory to upload Logger for output

Uploads a directory to the remote using a specific filter list

The local directory to copy from The remote directory to copy to List of paths to filter Logger for output

Upload all the files in the workspace for the current project

Downloads a single file from the remote

The file to download Logger for output

Download multiple files from the remote Mac

List of local files to download Logger for output

Checks whether a directory exists on the remote machine

Path to the directory on the local machine Logger for output True if the remote directory exists

Download a directory from the remote Mac

Directory to download Logger for output

Execute Rsync

Arguments for the Rsync command Logger for output Exit code from Rsync

Handles data output by rsync

The received datae whether the data was received on stderr Logger for output

Execute a command on the remote in the remote equivalent of a local directory

Logger for output

Execute a remote command, capturing the output text

The remote working directory Command to be executed Logger for output If true, logging is suppressed

Handler for output from running remote SSH commands

whether the data was received on stderr Logger for output

Execute a remote command, capturing the output text

Command to be executed Logger for output Receives the output text

Converts any remote paths within the given string to local format

The text containing strings to convert The string with paths converted to local format

Allows a toolchain to decide to create an import library if needed for this Environment

Get the name of the response file for the current compile environment and output file

Get the name of the response file for the current linker environment and output file

Adds a build product and its associated debug file to a receipt.

Build product to add The type of build product

This is the extension of the file that is added as extra link object. It can be an obj file but also a dynamic list.. depends on the platform

The extension (without dot)

Runs the provided tool and argument. Returns the output, using a rexex capture if one is provided

Full path to the tool to run Argument that will be passed to the tool null, or a Regular expression to capture in the output

Runs the provided tool and argument and parses the output to retrieve the version

Full path to the tool to run Argument that will result in the version string being shown (it's ok this is a byproduct of a command that returns an error) Regular expression to capture the version. By default we look for four integers separated by periods, with the last two optional

Save the application startup time. This can be used as the timestamp for build makefiles, to determine a base time after which any modifications should invalidate it.

Whether this is a recursive run of of the application

Unique id to track this session

The mode of this instance

The result of running the application

The environment at boot time.

The full name of the Engine/Source directory

Cached copy of the source root directory that was used to compile the installed engine Used to remap source code paths when debugging.

Writable engine directory. Uses the user's settings folder for installed builds.

The engine programs directory

The original root directory that was used to compile the installed engine Used to remap source code paths when debugging.

The Remote Ini directory. This should always be valid when compiling using a remote server.

Returns true if UnrealBuildTool is running using an installed project (ie. a mod kit)

True if running using an installed project

Gets the installed project file

Location of the installed project file

Checks whether the given file is under an installed directory, and should not be overridden

File to test True if the file is part of the installed distribution, false otherwise

Gets the absolute path to the UBT assembly.

A string containing the path to the UBT assembly.

The Unreal remote tool ini directory. This should be valid if compiling using a remote server

The directory path

Global options for UBT (any modes)

User asked for help

The amount of detail to write to the log

Specifies the path to a log file to write. Note that the default mode (eg. building, generating project files) will create a log file by default if this not specified.

Log all attempts to write to the specified file

Whether to include timestamps in the log

Whether to format messages in MsBuild format

Whether or not to suppress warnings of missing SDKs from warnings to LogEventType.Log in UEBuildPlatformSDK.cs

Whether to write progress markup in a format that can be parsed by other programs

Whether to ignore the mutex

Whether to wait for the mutex rather than aborting immediately

The mode to execute

Whether to backup an existing log file, rather than overwriting it.

The number of log file backups to preserve. Older backups will be deleted.

If set TMP\TEMP will be overidden to this directory, each process will create a unique subdirectory in this folder.

If set the application temp directory will be deleted on exit, only when running with a single instance mutex.

Providers to load opt-in telemetry connection information from ini. If unset, or the provider categories do not contain connection info, no telemetry will be sent.

Additional command line providers to load opt-in telemetry connection information from ini.

Session identifier for this run of UBT, if unset defaults to a random Guid

Initialize the options with the given command line arguments

Get all the valid Modes

Print (incomplete) usage information

Read extra command-line arguments from an environment variable Double-quote any argument containing whitespace, as they are split by just that.

Extra arguments

Event handler for the Console.CancelKeyPress event

Main entry point. Parses any global options and initializes the logging system, then invokes the appropriate command. NB: That the entry point is deliberately NOT async, since we have a single-instance mutex that cannot be disposed from a different thread.

Command line arguments Zero on success, non-zero on error

Helper functionality for easier F5 debugging for blueprint-only projects

Path to the .uproject file to use when F5 debugging a content-only project via the UE5 engine project

Get the configured content-only debug project, if any

Helper function to get the content-only debug project for the given target, if applicable and supported

Stores the path to the content-only debug project in the target receipt

Retrieves the path to the project from the given target receipt

Retrieves the path to the project from the given target

Helper functionality for optionally auditing the GDK edition on any used lib and dll files

Whether to verify that any libs the application links to are using the same GDK edition

Whether to verify that any DLLs the application links to are using the same GDK edition

Submission validator xml report can suggest multiple GDK editions for a single executable - the additional ones come from the libs that are linked to. This function checks all the libs we are planning to link against and warns if they were built against a different GDK

Optionally verify that any DLLs the application links to are using the same GDK edition

Public GDK functions exposed to UAT

Returns the top-level root directory of the GameCore SDK

Returns the root directory for the current version of the GameCore SDK

Returns the SDK binaries directory

Determines the directory containing the MSVC toolchain

Major version of the compiler to use The minimum compiler version to use. Can be "Latest" Architecture that is required Logger for output Receives the directory containing the toolchain Receives the optional directory containing redistributable components True if the toolchain directory was found correctly

Returns the directory where GDK Extension SDKs are located

Returns the installed version of the GDK

Returns the installed version number of the GDK

(Experimental and unsupported) Modifies the given target rules so that it will produce a build that is compatible with PC GDK. Expected for Win64 TargetInfo only. If using bUseCustomConfig=true, it is necessary to add the following entries to {project dir}/Config/Windows/Custom/MSGameStore/WindowsEngine.ini Otherwise, when bUseCustomConfig=false, add these to {project dir}/Config/Windows/WindowsEngine.ini ; (required) this is required to make BuildCookRun generate, deploy and launch msixvc packages [/Script/WindowsTargetPlatform.WindowsTargetSettings] CustomDeployment=MSGameStore ; (recommended) add this if you are expecting to do intelligent delivery and use on-demand chunks etc [StreamingInstall] DefaultProviderName=GDKPackageChunkInstall ; (recommended) add these if you are planning on using Xbox cross-platform save games [PlatformFeatures] PlatformFeaturesModule=MSGameStorePlatformFeatures SaveGameSystemModule=GDKSaveGameSystem ; (optional) set this if you are using EOSSDK [/Script/MSGamingRuntimeEditor.MSGamingRuntimeSettings] +AllowedMissingSymbolFiles="EOSSDK-Win64-Shipping.DLL" ; (optional) set this if you use bWithOSS=true [OnlineSubsystem] DefaultPlatformService=GDK ; (optional) only need the following sections if you use bWithPlayFab=true [/Script/Engine.Engine] !NetDriverDefinitions=ClearArray +NetDriverDefinitions=(DefName="GameNetDriver",DriverClassName="/Script/PlayFabParty.PlayFabPartyNetDriver",DriverClassNameFallback="/Script/PlayFabParty.PlayFabPartyNetDriver") +NetDriverDefinitions=(DefName="BeaconNetDriver",DriverClassName="/Script/PlayFabParty.PlayFabPartyNetDriver",DriverClassNameFallback="/Script/PlayFabParty.PlayFabPartyNetDriver") +NetDriverDefinitions=(DefName="DemoNetDriver",DriverClassName="/Script/Engine.DemoNetDriver",DriverClassNameFallback="/Script/Engine.DemoNetDriver") [PlayFab] AppId={Your Hex PlayFab Title ID String Here} If using bUseCustomConfig=true, it is necessary to add the following entries to {project dir}/Config/Windows/Custom/MSGameStore/WindowsGame.ini: Othewreise, when bUseCustomConfig=false, add these to {project dir}/Config/Windows/WindowsGame.ini ; (required) this is necessary to stage the game for Win64 because GDK is a restricted platform folder [Staging] +RemapDirectories=(From="Engine/Platforms/GDK", To="Engine") +RemapDirectories=(From="{project dir}/Platforms/GDK", To="{project dir}")

Whether you have put all MSGameStore config settings in Config/Custom/MSGameStore/*.ini - typically done with a custom MSG build target MyGameMSGTarget : MyGameTarget Whether to include the OnlineSubsystemGDK plugin. Requires additional config settings Whether to include the PlayFab plugin. Requires additional config settings

GDK-specific appx manifest generator (MicrosoftGame.config)

Platform-specific target device family Platform-specific architecture DLC file to use, if any Cached properties for the current DLC Helper to check if we are dealing with DLC Whether we have a bootstrap exe (Windows only) - affects dependencies

Create a manifest generator for the given platform variant.

Create a manifest for the given platform and return the list of modified files

Get the Game element

Get the executable list element

Get the executable element for the given configuration

Get the protocol list element

Get the media capture element

Get the shell visuals element

Get the default display name for the project

Gets the package identity name string for the main package, disregarding any current DLC

Get the package identity name string

Get the package version string

manifest version. 0 = original, 1 = March 2022 GDK and above

Perform any additional initialization once all parameters and configuration are ready

Create all the localization data. Returns whether there is any localization data

Return the entire manifest element

Register the locations where resource binary files can be found

Perform any platform-specific processing on the manifest before it is saved

Returns the package full name for the given project

Returns the package family name for the given project

Returns the AUMID for the given project and configuration

Get the manifest generator for the given platform

ToolMode to create a MicrosoftGame.config for a single executable pair

Helper function to create an action that will run this ToolMode

Helper class used to manage GDK manifest identities

Regular expression for standard Micrososoft full package name: Name_Version_ProcessorArchitecture_ResourceId_PublisherId Regular expression for standard Microsoft AUMID: Name_PublisherId!AppName Architecture to use when none is specified Version to use when none is specified The package identity. e.g. "GameName" The package version. e.g. "1.0.0.0" The package Architecture. e.g. "neutral", "x64" etc. The package resource id. (not used on GDK) The package publisher id. e.g. "z844xmwvfmpty" The full Package Name. e.g. "GameName_1.0.0.0_neutral__z844xmwvfmpty" The package family name. e.g. "GameName_z844xmwvfmpty" only valid if we are created from a MicrosoftGame.config only valid if we are created from a MicrosoftGame.config or via ParseAppList

Create empty manifest identity

Create a manifest based on a given package full name. e.g. "GameName_1.0.0.0_neutral__z844xmwvfmpty"

Create a manifest identity from the given manifest file

Query whether there are executables available in this manifest

Look up the relative path to the given executable, if it is mentioned

Returns the AUMID for the given manifest and executable file name. e.g. GameName_z844xmwvfmpty!AppGameNameDevelopment

Returns the AUMID that matches the given configuration

Returns the executable that matches the given configuration

Returns the executable that matches the given AUMID

Returns all AUMIDs in the manifest

Standard ToString override

Converts a human-readable Publisher Name into the Publisher Id used by MS app manifests

Returns the full package name from the given manifest. e.g. GameName_1.0.0.0_neutral__z844xmwvfmpty

Returns the package family name from the given manifest. e.g. GameName_z844xmwvfmpty

Returns the AUMID for the given manifest and executable file name. e.g. GameName_z844xmwvfmpty!AppGameNameDevelopment

Returns the AUMID that matches the given configuration from a list of AUMIDs

Structure containing information about an installed GDK application

The type of application

Unknown Loose folder Installed package Network share core MicrosoftGame.config information deployment type - staged or packaged registration state display name deployment path

Returns a list of all applications from the given app list /json output

List of all applications

Create a manifest generator for Win64 using MSGameStore

Create a manifest generator for other platforms

Register the locations where resource binary files can be found

Create a manifest generator for WinGDK

Create a manifest generator for XB1

Create a manifest generator for the given platform variant

Create a manifest generator for XSX

Whether platform supports switching SDKs during runtime

true if supports

platforms can choose if they prefer a correct the the AutoSDK install over the manual install.

The minimum Windows SDK version to be used. If this is null then it means there is no minimum version

The maximum Windows SDK version to be used. If this is null then it means "Latest"

Public MSGameStore functions exposed to UAT

Type of custom install action command for installing command for repairing command for uninstalling a custom install action location to copy the custom installs to when staging name of the install action source folder, relative to engine root a command to run and its arguments command to run arguments to pass to the given command the commands to run for each action read the given config key and return the actions

Determine whether Windows is in developer mode. PC GDK packages can't be sideloaded without it

Determine if the Microsoft.GamingServices package is installed.

Determine whether the local version of Windows can support GDK

Base Nintendo functions exposed to UAT

Which UnrealTargetConfiguration to build the meta file for Zero out the version when creating the meta file, used when generating small app big patch scenario Suggested ApplicationVersion to override what's in meta

Path to .desc file for referenced project

Determines if the megazarf can be installed to the default Install RootDir set in the MZ. This decision is based on whether the drive specified is valid

The platform to use The path of the megazarf to inspect Whether NNPM must be used to install the megazarf An alternate path to install the MZ to. It is based on the directory structure of the original path, and the first available, valid drive. An alternate environment name to install the MZ to. It is based on the directory structure of the original path, and the first available, valid drive. true if the destination drive is invalid, otherwise false

Returns an integer value for the installed Switch SDK version.

Returns the Major, Minor, Patch values ored together.

Returns if the platform is using an SDK that uses the new refactored directory structure

Returns an integer value for the supplied Major, Minor, and Patch Switch SDK version strings.

The Major version number. The Minor version number. The Patch version number. Returns the Major, Minor, Patch values ored together.

Returns an integer value for the supplied Major, Minor, and Patch Switch SDK version strings.

The Major version number. The Minor version number. The Patch version number. Returns the Major, Minor, Patch values ored together.

Returns the semantic version given an integer version.

The version as an integer. Returns the Major, Minor, Patch values.

Searches Target Manager folders for requested file.

The name of the file requested. This will contain the root Target Manager directory if the file is found. Returns the path to the file or null if it wasn't found.

Searches Target Manager folders for requested file.

The name of the file requested. Returns the path to the file or null if it wasn't found.

location of libraries in the SDK

location of libraries in the SDK

location of the SDK on disk (requires the NINTENDO_SDK_ROOT environment variable)

Defines which Nintendo online server the game is connecting to

Doesn't connect to Nintendo Online Servers.

Use Nintendo NEX Game Servers (deprecated, requires Nintendo Online subscription)

Use Nintendo NPLN Game Servers (requires Nintendo Online subscription)

Nintendo platform target settings

base frameworks used for all projects. stored here so we have access to them in ModifyBuildProducts()

Enable/disable NEX library support. Allows fully compiling out NEX support. Deprecated: Use "NintendoGameServersMode" instead

Choose which online service we are currently targeting. If NEX/NPLN are not selected, they will be compiled out. Possible Options: None (default) NEX (legacy,deprecated) NPLN (new Nintendo online service)

Generate symbols with Breakpad (non shipping only).

Generate symbols with Breakpad (non shipping only), and only when compiled from a machine with the IsBuildMachine environment variable enabled.

Enable/disable system profilers, this can reduce program size.

Enable/disable the custom user exception handler.

Enable the custom user exception handler, only when compiled from a machine with the IsBuildMachine environment variable enabled.

Force Development libraries.

Enable Aftermath per build configuration (automatically opted out in shipping) Enabling it automatically disables LLGD and NVNGD

Override malloc heap size. NOTE this has been removed. There is no longer a separate heap for malloc, allocations now go through FNintendoPlatformMemory::BaseAllocator.

Max number of slots FNintendoPlatformTLS::AllocTlsSlot can allocate.

Max number threads that can use FNintendoPlatformTLS at one time.

The amount of memory donated to the NVN graphics firmware (must be a multiple of 4).

Controls how the game uses the touchscreen. Due to LotCheck, this will force a full recompile to add/remove the touch APIs from the code. Content-only projects will convert to code if this is not the default value!

Enable the four finger tap debugging option to show a web page for entering console commands, which will force touch screen usage to Supported in non-Shipping builds (since it needs touch support!) NOTE: Content-only projects will convert to code if this is not the default value!

Optional application error code prefix - 5 characters

Enable the mechanism to monitor write speeds to system storage. Note, this is a best effort mechanism and may not catch all overages. Use the SDK tool FsAccessLogChecker for official results. See SDK Guideline 0011 for more info.

Size of the cache data storage in KB.

Size of the temp data storage in KB.

Modify code generation to help with debugging optimized builds by extending lifetimes of local variables, parameters and this. It may slightly reduce performance. Thus, it's meant to be used during development only.

Read-only wrapper around an existing NintendoTargetRules instance. This exposes target settings to modules without letting them to modify the global environment.

Constructor

The settings object to wrap

Accessors for fields on the inner TargetRules instance

If this platform can be compiled with SN-DBS

Setup the target environment for building

Settings for the target being compiled The compile environment for this target The link environment for this target

Setup the configuration environment for building

The target being built The global compile environment The global link environment

Whether platform supports switching SDKs during runtime

true if supports

Construct properly formatted version string from raw numbers

Version string with dot separating parts

Base class for platform-specific project generators

No documentation available.

Constructor

Command line arguments passed to the project generator

Enumerate all the platforms that this generator supports

Helper for parsing, generating and comparing PS4 version strings, in the form "xx.xx" where x is a digit.

The integer value representing this version.

Version string, as it appears in param.sfx/sfo

Parses the version string into its integer representation.

Parses the version string into its integer representation. Returns false if parsing failed.

Equality function

Returns the formatted version string

Returns the underlying value hashcode

Comparison function

Less than operator

Greater than operator

Equal operator

Not equal operator

Represent the types of packages the publishing tools can produce.

A regular, standalone package. Used for master release, and development.

A patch package based off a previous release.

A remaster package based off a previous release.

Helper class used to generate and parse package/GP4 file names according to their Content ID / versions etc in the form: XXYYYY-XXXXYYYYY_00-ZZZZZZZZZZZZZZZZ_11.11-22.22_Submission-TargetName-PS4-Configuration.pkg where: "XXYYYY-XXXXYYYYY_00-ZZZZZZZZZZZZZZZZ" is the package Content ID "11.11" is the Master Version "22.22" is the Application Version "Submission-" is optional, and denotes a submission package (--for_submission / -distribution) "TargetName" is the name of the UBT target binary the package was created for "Configuration" is the UBT target configuration

The generated name of the GP4 file

The generated name of the PKG file.

The generated build info string to embed in the .pkg file

Full Content ID string in the format "XXYYYY-XXXXYYYYY_00-ZZZZZZZZZZZZZZZZ"

The title ID portion of the content ID string in the format "XXXXYYYYY".

The version of an application or additional content to be submitted.

The version of an application or additional content to be updated.

True if this is a submission package.

The name of the target this package is built for.

The binary configuration included in the package.

Whether this is a standard, patch or remaster package.

Parses the given package filename into its component parts

Builds a PackageInfo instance from a title configuration and other properties.

Parses the given .pkg/.gp4 filename into its component parts. Returns false if parsing failed.

Parses the given .pkg/.gp4 filename into its component parts. Returns null if parsing failed.

Returns true if the specified package matches the current one (i.e. binary, config, submission etc match)

Searches the specified directory for a package matching this package info.

Contains the title configuration required for producing a packaged PS4 build. This code is shared between UBT project generation, and UAT packaging automation. See PS4ProjectGenerator.cs and PS4Platform.Automation.cs.

A regex pattern that matches valid content IDs

Full Content ID string in the format "XXYYYY-XXXXYYYYY_00-ZZZZZZZZZZZZZZZZ"

Just the Title ID portion of the full Content ID

True will suppress automation warnings about incorrect title configuration (e.g. missing passcodes / missing content ID / no default language). Used only for Unreal Engine sample projects which are not intended to be shipped as retail titles. Do not enable this if you are making a real game.

Represents the DRM type of the application, as specified by packaging documentation. Allowed values are "full", "upgradable", "demo", "freemium". If unspecified, assumes "full".

Indicates if this title configuration is allowed to include trophy data

The version of an application or additional content to be submitted.

The version of an application or additional content to be updated.

This setting selects whether packaging automation produces "remaster" or "patch" packages when building releases with the "-basedonreleaseversion" option. Refer to Sony packaging documentation for more information about which option to use for your title. By default, "patch" packages will be produced.

A map of ASA codes. Use of this field is only necessary if Sony requires specific ASA codes to be enabled for your title.

This setting selects whether packaging automation sets the 'Video Recording Library' option.

The default title name to use if a localized name is not provided for a specific culture in the title names map.

A map of culture IDs to title names for display in the system software. e.g. { "en-US" : "Game Name for English (US)", "fr" : Game Name for French" }

Passcode used for package creation.

The storage type of the package. The choice made here determines how the package can be shipped to retail (i.e. digital only, or via BluRay disc). Refer to Sony packaging documentation for more information.

The storage type to use when creating remaster packages. Refer to Sony packaging documentation for more information.

True indicates this package is to be distributed on blu-ray disc.

True indicates this package is to be distributed on a multi-layer blu-ray disc.

True indicates the UAT packaging process should generate the .iso disc image in addition to the .pkg package file.

The size in MiB of the /download0 data area for the title. Available options are 0, 256, 512, or 1024.

The size in MiB of the /download1 data area for the title. Available options are 0, 3328, 6656, 9984, 13312, or 16640.

The parent control level applied to the package. Refer to Sony TRC R4005 documentation for a detailed description of the meaning of this value, and set an appropriate value for your title.

Indicates that the title supports HDR output. This setting is reflected in the generated param.sfo file in staged and packaged builds.

Indicates if the application runs on the PlayStation 5 system, and adheres to TRC R4211. See Sony documentation.

Indicates if the application uses the sceKernelIsProspero API. See Sony documentation.

Settings of the proxy server to be used when checking the version of the Publishing Tools or the SDK online. - When using the system's proxy settings: "ie" - When manually entering proxy server information: "(IP address):(port number)" - When not using a proxy server: "none"

Project type (output format)

Entitlement key (only for additional content package)

DLC plugin name (only for additional content package)

Custom ParamSFO attribute2

Retrieves the title configurations from the specific config hierarchy.

Retrieves the title configurations from the specific config hierarchy. Also returns the default title configuration to use when a title or content ID is not provided on UBT command line.

Read overrides for TitleConfiguration fields from Engine's .ini scripts and return as a data structure compatible with what Json loading returns (ParseJson). This way, the overrides may be merged with the contents of the .jsons we load. Note: it only supports simple fields (bool, long, string); arrays and subobjects are ignored.

Engine configuration hierarchy Content id of the SKU for which to load overrides (global overrides a loaded when null)

PS4-specific target settings

Enable Razor CPU profiling

Set this to true to register shaders with the standalone GPU debugger.

Set this to true to enable Sulpha host side audio debugging.

Enables support for the PS4 Memory Analyzer tool.

Set this to true to enable gnm asserts and validations in the LCUE

Enable link time optimization for test/shipping builds.

Enable link time optimization for development/test/shipping builds.

Move the audio rendering and stats thread to the 7th core when available

Enables address sanitizer (ASan)

Enables undefined behavior sanitizer (UBSan)

Enables thread sanitizer (TSan) [not available on PS4]

Enables shader performance analysis

Enable support for edit and continue code modification on ps4

Per-platform override enabling support for edit and continue. If not provided, the global bSupportEditAndContinue setting will be applied.

Whether to improve iteration of a developer's build by skipping certain steps (currently, .uesym generation)

Disabled static analyzer checkers

Enable system runtime object stats in non shipping build

Modify code generation to help with debugging optimized builds by extending lifetimes of local variables, parameters and this.

Set this true to use the CrossgenSDK

Set this to true to disable NpToolkit

Read-only wrapper around an existing PS4TargetRules instance. This exposes target settings to modules without letting them to modify the global environment.

The private mutable settings object

Constructor

The settings object to wrap

Accessors for fields on the inner TargetRules instance

Set this true to use the CrossgenSDK

Set this true to disable the NpToolkit

Modify the rules for a newly created module, where the target is a different host platform. This is not required - but allows for hiding details of a particular platform.

The name of the module The module rules The target being build

Modify the rules for a newly created module, in a target that's being built for this platform. This is not required - but allows for hiding details of a particular platform.

The name of the module The module rules The target being build

Setup the target environment for building

Settings for the target being compiled The compile environment for this target The link environment for this target

Creates a toolchain instance for the given platform.

The target being built New toolchain instance.

Deploys the given target

Receipt for the target being deployed

Register the platform with the UEBuildPlatform class

Provides support for applying Kraken compression to staged builds, using split-compress-merge workflow if distributed build systems are available.

Whether platform supports switching SDKs during runtime

true if supports

Construct properly formatted version string from raw numbers

Version string with dot separating parts

Base class for platform-specific project generators

When enabled, generates project files that default to using the PS5 application debugger.

When enabled, generates project files where the PS5 local debugger is set to use a .gp5 file from the StagedBuild directory. Otherwise, the StagedBuild directory itself is set as the working directory, and the title is launched without the help of a .gp5 file.

Enumerate all the platforms that this generator supports

Helper for parsing, generating and comparing PS5 master version strings, in the form "xx.xx" where x is a digit.

The integer value representing this master version.

Master version string, as it appears in param.json

Parses the master version string into its integer representation.

Parses the master version string into its integer representation. Returns false if parsing failed.

Equality function

Returns the formatted version string

Returns the underlying value hashcode

Comparison function

Less than operator

Greater than operator

Equal operator

Not equal operator

Helper for parsing, generating and comparing PS5 content version strings, in the form "xx.xxx.xxx" where x is a digit.

The integer value representing this content version.

Content version string, as it appears in param.json

Parses the master version string into its integer representation.

Parses the content version string into its integer representation. Returns false if parsing failed.

Equality function

Returns the formatted version string

Returns the underlying value hashcode

Comparison function

Less than operator

Greater than operator

Equal operator

Not equal operator

Helper class used to generate and parse package/GP5 file names according to their Content ID / versions etc in the form: XXYYYY-XXXXYYYYY_00-ZZZZZZZZZZZZZZZZ_01.00-01.000.000_Shared-Submission-TargetName-PS5-Configuration.pkg where: "XXYYYY-XXXXYYYYY_00-ZZZZZZZZZZZZZZZZ" is the package Content ID "01.00" is the MasterVersion "01.000.000" is the ContentVersion "Shared-" is optional, and denotes a shared binary package "Submission-" is optional, and denotes a submission package (--for_submission / -distribution) "TargetName" is the name of the UBT target binary the package was created for "Configuration" is the UBT target configuration

The generated name of the build.

The generated name of the GP5 file.

The generated name of the PKG file.

Full Content ID string in the format "XXYYYY-XXXXYYYYY_00-ZZZZZZZZZZZZZZZZ"

The title ID portion of the content ID string in the format "XXXXYYYYY".

The version of an application or additional content to be submitted.

The version of an application or additional content to be updated.

True indicates the title should be packaged as a shared binary. This means a single package is produced, containing the files for all listed Content IDs, rather than one package per Content ID.

True if this is a submission package.

The name of the target this package is built for.

The binary configuration included in the package.

Parses the given package filename into its component parts

Builds a PackageInfo instance from a title configuration and other properties.

Parses the given .pkg/.gp5 filename into its component parts. Returns false if parsing failed.

Parses the given .pkg/.gp5 filename into its component parts. Returns null if parsing failed.

Returns true if the specified package matches the current one, and has an older ContentVersion.

Contains the title configuration required for producing a packaged PS5 build. This code is shared between UBT project generation, and UAT packaging automation. See PS5ProjectGenerator.cs and PS5Platform.Automation.cs.

A regex pattern that matches valid content IDs

Full Content ID string in the format "XXYYYY-XXXXYYYYY_00-ZZZZZZZZZZZZZZZZ"

Just the Title ID portion of the full Content ID

The Concept ID value for the title, as provided by the GEMS tool.

Passcode used for package creation.

Represents the DRM type of the application, as specified by packaging documentation. Allowed values are "standard", "upgradable", or "demo". If unspecified, assumes "standard".

The version of an application or additional content to be submitted.

The version of an application or additional content to be updated.

True indicates the title should be packaged as a shared binary. This means a single package is produced, containing the files for all listed Content IDs, rather than one package per Content ID.

True will suppress automation warnings about incorrect title configuration (e.g. missing passcodes / missing content ID / no default language). Used only for Unreal Engine sample projects which are not intended to be shipped as retail titles. Do not enable this if you are making a real game.

Determines whether generated packages support Blu-ray disc distribution, and if so, what type of Blu-ray disc. If unspecified, assumes "nwonly", i.e. online distribution only, no Blu-ray disc.

True indicates that the title correctly handles log in/log out of the initial user.

True indicates the title supports HDR rendering.

True indicates the title uses the content search library rendering.

True indicates the title uses the share library capture API.

True indicates the title is a beta release.

When true, indicates the title will use the faster startup splash screen animation, which reduces the time it takes for the game logo (pic2.png) to appear. See the "Content Information Specifications -> 7. Start-up Image [Application Information]" section of the Sony documentation.

If VR support is enabled a value of 1 indicates that the app Supports VR, a value of 2 indicates that the app Requires VR. Allowed values are "supported", or "required". If unspecified, assumes "supported".

The size in MiB of the download data area for the title. Available options are 0, 256, 512, or 1024.

The content badge type value for the title, as provided by the GEMS tool.

A map of region IDs to age levels required to play the title. The entry with an empty string "" key is used as the default age level. e.g. { "": 15, "US": 10, "JP": 14 }

The default title name to use if a localized name is not provided for a specific culture in the title names map.

A map of culture IDs to title names for display in the system software. The entry with an empty string "" key is used as the default name. e.g. { "": "Default Game Name", "en-US" : "Game Name for English (US)" }

A list of game intents applicable to this title.

The version file uri string as provided by the GEMS tool in param_cp_values.json.

A map of ASA codes. Use of this field is only necessary if Sony requires specific ASA codes to be enabled for your title.

A list of ASA signatures. Use of this field is only necessary if Sony requires specific ASA signatures to be enabled for your title.

Project type (output format)

Entitlement key (only for additional content package)

DLC plugin name (only for additional content package)

A dictionary of properties which should also be included in the generated param.json file. This dictionary is merged with the values that are generated from the above properties. Useful if a property needs to be added to param.json, but there is no explicit UAT code support for that property.

A map of configuration to size to override flexible memory size.

Contains the title and description of a scenario for a given language.

The title of the scenario.

A description of the scenario.

Contains the configuration for an individual scenario.

Constructor

A map of culture IDs to scenario title names / descriptions for display in the system software.

A map of scenario IDs their configuration data.

Retrieves the title configurations from the specific config hierarchy.

Retrieves the title configurations from the specific config hierarchy. Also returns the default title configuration to use when a title or content ID is not provided on UBT command line.

Read overrides for TitleConfiguration fields from Engine's .ini scripts and return as a data structure compatible with what Json loading returns (ParseJson). This way, the overrides may be merged with the contents of the .jsons we load. Note: it only supports simple fields (bool, long, string); arrays and subobjects are ignored.

Engine configuration hierarchy Content id of the SKU for which to load overrides (global overrides a loaded when null)

PS5-specific target settings

Enable Razor CPU profiling

Set this to true to register shaders with the standalone GPU debugger.

Set this to true to enable Sulpha host side audio debugging.

Enables support for the PS5 Memory Analyzer tool.

Enable link time optimization for test/shipping builds.

Enable link time optimization for development/test/shipping builds.

Enables address sanitizer (ASan) Address sanitizer significantly increases the amount of flexible memory used by a title. For this reason, a staged build with a manually updated param.json with the following change is generally needed (the required size is title-dependent): "kernel": { "flexibleMemorySize": 1073741824 }, Alternatively, a flexible memory override may be specified when launching from Visual Studio or Sony tools (Target Manager, Remote Viewer).

Enables undefined behavior sanitizer (UBSan)

Enables thread sanitizer (TSan)

Enables shader live editing support.

Enable support for edit and continue code modification

Per-platform override enabling support for edit and continue. If not provided, the global bSupportEditAndContinue setting will be applied.

Whether to improve iteration of a developer's build by skipping certain steps (currently, .uesym generation)

Disabled static analyzer checkers

Enable system runtime object stats in non shipping build

Modify code generation to help with debugging optimized builds by extending lifetimes of local variables, parameters and this.

Indicates whether the PS5 kernel extension allowing us to load more than 255 .prx modules is available. It's really only necessary when using modular builds (which itself is an experimental feature at the moment).

Read-only wrapper around an existing PS5TargetRules instance. This exposes target settings to modules without letting them to modify the global environment.

The private mutable settings object

Constructor

The settings object to wrap

Accessors for fields on the inner TargetRules instance

Modify the rules for a newly created module, where the target is a different host platform. This is not required - but allows for hiding details of a particular platform.

The name of the module The module rules The target being build

Modify the rules for a newly created module, in a target that's being built for this platform. This is not required - but allows for hiding details of a particular platform.

The name of the module The module rules The target being build

Setup the target environment for building

Settings for the target being compiled The compile environment for this target The link environment for this target

Creates a toolchain instance for the given platform.

The target being built New toolchain instance.

Deploys the given target

Information about the target being deployed

Register the platform with the UEBuildPlatform class

Construct properly formatted version string from raw numbers

Version string with dot separating parts

Base class for project generators for Sony platforms.

Get host compiler path for ISPC.

Which OS build platform is running on. Path to ISPC compiler

Get the host bytecode-to-obj compiler path for ISPC. Only used for platforms that support compiling ISPC to LLVM bytecode

Which OS build platform is running on. Path to bytecode to obj compiler

Sony-specific target settings

Enable Razor CPU profiling

Set this to true to register shaders with the standalone GPU debugger.

Set this to true to enable Sulpha host side audio debugging.

Enables support for the Sony Memory Analyzer tool.

Enable link time optimization for test/shipping builds.

Enable link time optimization for development/test/shipping builds.

Enables address sanitizer (ASan)

Enables undefined behavior sanitizer (UBSan)

Enables thread sanitizer (TSan)

Enable support for edit and continue code modification on Sony

Per-platform override enabling support for edit and continue. If not provided, the global bSupportEditAndContinue setting will be applied.

Whether to improve iteration of a developer's build by skipping certain steps (currently, .uesym generation)

Disabled static analyzer checkers

Enable system runtime object stats in non shipping build

Modify code generation to help with debugging optimized builds by extending lifetimes of local variables, parameters and this. It may slightly reduce performance. Thus, it's meant to be used during development only.

Read-only wrapper around an existing SonyTargetRules instance. This exposes target settings to modules without letting them to modify the global environment.

Constructor

The settings object to wrap

Accessors for fields on the inner TargetRules instance

If this platform can be compiled with XGE

If this platform can be compiled with SN-DBS

Determines if the given name is a build product for a target.

The name to check Target or application names that may appear at the start of the build product name (eg. "UnrealEditor", "ShooterGameEditor") Suffixes which may appear at the end of the build product name True if the string matches the name of a build product, false otherwise

Get the extension to use for the given binary type

The binrary type being built string The binary extenstion (ie 'exe' or 'dll')

Get the extensions to use for debug info for the given binary type

Rules for the target being built The binary type being built string[] The debug info extensions (i.e. 'pdb')

Whether this platform should build a monolithic binary

Whether this platform should create debug information or not

The target being built bool true if debug info should be generated, false if not

Setup the configuration environment for building

The target being built The global compile environment The global link environment

Setup the binaries for this specific platform.

The target being built

Public Switch functions exposed to UAT

location of libraries in the SDK

Base class for platform-specific project generators

Constructor

Command line arguments passed to the project generator Logger for output

Enumerate all the platforms that this generator supports

Switch-specific target settings

Name to use for the Runtime Settings section in the INI config files

base frameworks used for all projects. stored here so we have access to them in ModifyBuildProducts()

Enable/disable NEX library support. Allows fully compiling out NEX support. Deprecated: Use "NintendoGameServersMode" instead

Choose which online service we are currently targeting. If NEX/NPLN are not selected, they will be compiled out. Possible Options: None (default) NEX (legacy,deprecated) NPLN (new Nintendo online service)

Generate symbols with Breakpad (non shipping only).

Generate symbols with Breakpad (non shipping only), and only when compiled from a machine with the IsBuildMachine environment variable enabled.

Enable/disable system profilers, this can reduce program size.

Enable/disable the custom user exception handler.

Enable the custom user exception handler, only when compiled from a machine with the IsBuildMachine environment variable enabled.

Force Development libraries.

Enable Aftermath per build configuration (automatically opted out in shipping) Enabling it automatically disables LLGD and NVNGD

Override malloc heap size. NOTE this has been removed. There is no longer a separate heap for malloc, allocations now go through FSwitchPlatformMemory::BaseAllocator.

Max number of slots FSwitchPlatformTLS::AllocTlsSlot can allocate.

Max number threads that can use FSwitchPlatformTLS at one time.

The amount of memory donated to the NVN graphics firmware (must be a multiple of 4).

Controls how the game uses the touchscreen. Due to LotCheck, this will force a full recompile to add/remove the touch APIs from the code. Content-only projects will convert to code if this is not the default value!

Enable the four finger tap debugging option to show a web page for entering console commands, which will force touch screen usage to Supported in non-Shipping builds (since it needs touch support!) NOTE: Content-only projects will convert to code if this is not the default value!

Optional application error code prefix - 5 characters

Enable the mechanism to monitor write speeds to system storage. Note, this is a best effort mechanism and may not catch all overages. Use the SDK tool FsAccessLogChecker for official results. See SDK Guideline 0011 for more info.

Size of the cache data storage in KB.

Size of the temp data storage in KB.

Modify code generation to help with debugging optimized builds by extending lifetimes of local variables, parameters and this. It may slightly reduce performance. Thus, it's meant to be used during development only.

Read-only wrapper around an existing SwitchTargetRules instance. This exposes target settings to modules without letting them to modify the global environment.

Constructor

The settings object to wrap

Setup the target environment for building

Settings for the target being compiled The compile environment for this target The link environment for this target

Creates a toolchain instance for the given platform.

The target being built New toolchain instance.

Register the platform with the UEBuildPlatform class

Public VisionOS functions exposed to UAT

Constructor

Command line arguments passed to the project generator Logger for output

Enumerate all the platforms that this generator supports

Target rules for WinGDK

Whether exceptions should be ultimately passed on to Windows Error Reporting

Whether the embadded manifest will indicate the application is DPI aware

Read only target rules for WinGDK

Base class for platform-specific project generators

Constructor

Command line arguments passed to the project generator

Enumerate all the platforms that this generator supports

Target rules for XB1

Name to use for the Runtime Settings section in the INI config files

Report warnings about migrating deprecated XboxOneGDK platform to XB1

Read only target rules for XB1

Target rules for XboxCommon

Enable PIX debugging (automatically disabled in Shipping and Test configs)

Register the log file with Wer so it'll be uploaded along with crash dumps

Register screenshot file with Wer so it'll be uploaded along with crash dumps

Always run Wer even in non-shipping builds. Default value for xb.AlwayRunWer cvar.

The stack size when linking. 0 signifies use of system default.

The stack size override when linking for the debug configuration. 0 signifies use of system default.

The stack size to commit when linking. 0 signifies use of system default.

If -PGOOptimize is specified but the linker flags have changed since the last -PGOProfile, this will emit a warning and build without PGO instead of failing during link with LNK1268. Note that the PLATFORM_COMPILER_OPTIMIZATION_PG definition will still be 1 but FPlatformMisc::IsPGOEnabled() will return false in this case.

If specified along with -PGOProfile, then /FASTGENPROFILE will be used instead of /GENPROFILE. This usually means that the PGO data is generated faster, but the resulting data may not yield as efficient optimizations during -PGOOptimize

If specified along with -PGOProfile, prevent the usage of extra counters. Please note that by default /FASTGENPROFILE doesn't use extra counters https://learn.microsoft.com/en-us/cpp/build/reference/genprofile-fastgenprofile-generate-profiling-instrumented-build?view=msvc-170

Override the default compiler

Override the default compiler version

True if we should use the LLVM linker (LLD-Link.exe) when we are compiling with Clang. Otherwise we'll use the MSVC linker (Link.exe). This is required for LTO and PGO

Xbox should use the onecore libraries by default. This is included for backwards compatibility on some titles

ASan runtime options (delimited with colons ":")

Whether to support /host/ prefix in file system paths, allowing access to files on the host PC. It requires a full PC path but only files within the current solution dir are available. For example, -cvarsini=/host/D:\UE5\Engine\Config\ConsoleVariables.ini

Whether to improve iteration of a developer's build by skipping certain steps (currently, debug symbol lookup generation)

Read only target rules for XboxCommon

This adds support for a range of extra deployment scenarios for F5 in Visual Studio, including package debugging assistance. Disabling this may yield minor deployment speed increase at the cost of ease-of-use for more advanced deployment scenarios

Whether to deploy the current Staged build when F5 debugging from Visual Studio

Whether the staged build deployment will be skipped if there is already a build installed.

Prevents VS deployment if there will not be a build installed - otherwise VS will just deploy the Layout folder but no content and the game would likely crash.

Logs out additional information during package debugging assistance. Mostly useful for debugging this system

Prepare the target for deployment. This is done after the executable has been built, including when pressing F5 in Visual Studio.

Receipt for the target being deployed True if successful, false if not

Utility function to delete a file even if it is read-only

Helper function for copying modified files

Target rules for XSX

Name to use for the Runtime Settings section in the INI config files

Enables support for 120hz and 40hz display output. Use 'r.SetFramePace' to configure the desired output frame rate at runtime.

Enables support for SMT (Simultaneous Multi-threading) this is an immediate drop in cpu frequency of 10% but with hyperthreading.

Read only target rules for XSX

Return the AutoSDK property include to set global platform properties if AutoSDK is in use.

Attempts to optimize the module dependencies found in the build.cs files

Regex that matches #include statements.

Execute the command

Command line arguments Exit code

Information about a module that needs to be passed to the Verse VNI tool for code generation

Module name

Name of plugin this module belongs to, "Engine" or "Game"

Verse path of the root Verse module associated with this build module

If Verse code associated with this module is allowed to be seen by users outside of Epic

Path to the module rules file

Directory where the Verse package is located

Names of modules with Verse code that this module's Verse code depends on

Directory containing generated code

This handles all running of the VNI tool

Create a Verse vproject file from a list of VNIModuleInfo

Gets VNI Tool binary path

Runs the precompiled VNI tool Since the VNI tool performs extensive file date/manifest checking already we're not spending time here determining if it should be run in the first place, but run it _always_

Extension methods for JsonObject to provide some deprecated field helpers

Tries to read a string array field by the given name from the object; if that's not found, checks for an older deprecated name

JSON object to check Name of the field to get Backup field name to check On success, receives the field value True if the field could be read, false otherwise

Tries to read an enum array field by the given name from the object; if that's not found, checks for an older deprecated name

JSON object to check Name of the field to get Backup field name to check On success, receives the field value True if the field could be read, false otherwise

Whether this platform should build a monolithic binary

Allows the platform header name to be overridden to differ from the platform name. GDK platforms do not utilize an override for the platform header name.

Register the platform with the UEBuildPlatform class

Adds the XB1-specific shader format definitions

Register the platform with the UEBuildPlatform class

Whether this platform should create debug information or not

The target being built bool true if debug info should be generated, false if not

Whether this platform should build a monolithic binary

Get a list of extra modules the platform requires. This is to allow undisclosed platforms to add modules they need without exposing information about the platform.

The target being build List of extra modules the platform needs to add to the target

Allows the platform header name to be overridden to differ from the platform name.

Adds the GDK-specific shader format definitions

Register the platform with the UEBuildPlatform class