MICHAEL DELVA

UE4 Naming Convention Validation plugin

Wed, 23 Jun 2021 00:00:00 +0000

Over the last few years I have developed a few different UE4 plugins which are open source on GitHub. I figured this would be a good idea to talk about them here on this blog, as they proved to be very useful while developing our games at Fishing Cactus.

Let’s start with the Naming Convention Validation plugin !

This plugin has the same base as the DataValidation plugin from UE. It provides the same editor context menu options, to validate naming of individual assets, or assets in a folder. It can also be run as a commandlet, on a continuous integration system for example. It will then output all the errors it could find in the log, which you can then parse using regular expressions for example.

But first things first, you can access the plugin configuration in the project settings. You have different basic options which are self-explanatory.

But the real deal is with the Class Descriptions property:

This is in the class descriptions that you can specify which prefix and / or suffix are required in the name of assets, depending on their type. If an asset matches multiple descriptions, there’s the Priority property to filter them out.

Once everything is setup, you can right click in the content browser on some assets or folders, and select Validate Assets Naming Convention:

The results of the validation will then be added to the message log:

While the class descriptions are fine to validate individual assets, sometimes you want more elaborate conventions. For example, you may require all assets in a Weapons folder to have the weapon name in their asset name.

To achieve that, you can create a class which derives from UEditorNamingValidatorBase. You then just have to override the functions CanValidateAssetNaming and ValidateAssetNaming. This allows you to have more context about the asset, like its full path, and to implement more complex validation schemes.

You can find such an example here.

As with the data validation plugin bundled with UE, the plugin comes with a commandlet which allows you to validate the naming convention using the command line. This is most useful in the context of a continuous integration system, in which you can fail a job if an asset is wrongly named.

On one of our projects, we trigger that commandlet using Buildgraph, using the following XML node:

<Node Name="Naming Convention Validation" Requires="Compile SwarmsEditor Win64;">
    <Commandlet Name="NamingConventionValidation" Project="$(ProjectPath)" Arguments="-log -log=NamingConventionValidation.log -unattended -nopause -nullrhi" />
</Node>

After the commandlet is run, all the errors will be written in the log file, which you can parse using regular expressions.

That’s it for the quick presentation of that plugin. Thanks to it, we now enforce a real consistency in how the assets are named. This makes searching for assets in the editor faster, but has also other advantages, like avoiding errors when there’s a need to programatically construct a path to an asset.

The plugin is open source, has a permissive licence, so feel free to use it! Of course, pull requests are opened if you want to contribute to the project.

UE4 Unit Tests in Jenkins

Tue, 13 Nov 2018 00:00:00 +0000

On a personal project I try to work on during my spare time, I have written multiple unit tests to check some data is correct: for example, I check some given animation montages have the correct number of sections, which themselves are correctly named, etc…

The documentation about the automation is pretty solid, and I encourage you to go have a look if you don’t know what it is about.

It’s pretty straightforward to run the unit tests from within the editor, using the session frontend. But the task is a bit more complicated when you want to run the unit tests from within a jenkins job, and have the results parsed and displayed by jenkins.

The first step is to run the units tests from the command line. Here are the arguments I use in my jenkinsfile, based on that thread:

bat returnStatus: true, script: "\"${env.UE_ROOT_FOLDER}\\Engine\\Binaries\\Win64\\UE4Editor-Cmd.exe\" 
    \"${env.WORKSPACE}\\${env.PROJECT_NAME}.uproject\" 
    -unattended -nopause 
    -NullRHI
    -ExecCmds=\"Automation RunTests ${env.PROJECT_NAME}\"
    -testexit=\"Automation Test Queue Empty\" -log -log=RunTests.log 
    -ReportOutputPath=\"${env.WORKSPACE}\\Saved\\UnitTestsReport\""

A few things to note here:

I prefixed all my unit tests with my project name. This is why I use ${env.PROJECT_NAME} in ExecCmds.
NullRHI is used to avoid instantiate the whole editor. As of UE 4.20, this causes a crash when the tests are ended, but this has been fixed in UE 4.21
testexit is used to let the editor know it has to exit when the message “Automation Test Queue Empty” is logged
unattended and nopause are documented
ReportOutputPath is used to make UE4 generate a report in a JSON format in the destination folder

Once jenkins runs this step, you should have your tests runned, and the report generated. If that’s not the case, here are 2 issues I encountered:

in UE 4.20, if the Session Frontend tab is opened at the startup of the editor, despite the logs saying your tests were runned, they are not. This issue is fixed in UE 4.21, but the workaround is simple : close your session frontend tab, and close the editor, so that it does not show up again :)
My jenkins nodes run on Windows machines, and are connected to the jenkins master from a service. I had crashes when running the unit tests because the editor could not create the rendering swap chain when launched from the service. I had to revert back to connecting the slaves to the master with the JNLP applet, but maybe there is a way to change the service so it has the correct permissions. To be investigated…

Now that UE runs the unit tests and generates the JSON report, we have to make jenkins use this report to display the test results. The problem is that Jenkins can only natively use reports which fullful the jUnit XML format. So we have to convert that JSON into a valid XML file.

Here is the format of the JSON created by UE:

{
    "succeeded": 17,
    "succeededWithWarnings": 0,
    "failed": 1,
    "notRun": 0,
    "totalDuration": 10.075541496276855,
    "comparisonExported": true,
    "comparisonExportDirectory": "F:/Projects/RWC/Saved/TestReport/4369336",
    "tests": [
        {
            "testDisplayName": "AM_Dash_old",
            "fullTestPath": "RWC.AnimMontages.Dash.AM_Dash_old",
            "state": "Fail",
            "entries": [
                {
                    "event":
                    {
                        "type": "Error",
                        "message": "/Game/Characters/Player_Knight/Animations/Montages/AM_Dash_old - A dash montage must have exactly 4 sections: Back, Left, Right, Front",
                        "context": "",
                        "artifact": "00000000000000000000000000000000"
                    },
                    "filename": "f:\\projects\\rwc\\source\\rwceditor\\private\\tests\\rwcmontagesattacktests.cpp",
                    "lineNumber": 55,
                    "timestamp": "2018.11.12-15.01.02"
                }
            ],
            "warnings": 0,
            "errors": 1,
            "artifacts": []
        },
        {
            "testDisplayName": "AM_Attack_1H_Heavy_Charge",
            "fullTestPath": "RWC.AnimMontages.Attack.AM_Attack_1H_Heavy_Charge",
            "state": "Success",
            "entries": [],
            "warnings": 0,
            "errors": 0,
            "artifacts": []
        },
    ]
}

After numerous tries, here is what I got working so far:

def runUnitTests() {
    stage( "Unit Tests" ) {
        try {
            bat returnStatus: true, script: "\"${env.UE_ROOT_FOLDER}\\Engine\\Binaries\\Win64\\UE4Editor-Cmd.exe\" \"${env.WORKSPACE}\\${env.PROJECT_NAME}.uproject\" -ExecCmds=\"Automation RunTests ${env.PROJECT_NAME}\" -unattended -nopause -testexit=\"Automation Test Queue Empty\" -log -log=RunTests.log -NullRHI -ReportOutputPath=\"${env.WORKSPACE}\\Saved\\UnitTestsReport\""
        } catch ( Exception e ) {
        }

        convertUnitTestsReport()
        junit 'Saved/UnitTestsReport/junit.xml'
    }
}

def convertUnitTestsReport() {
    def json = readFile file: 'Saved/UnitTestsReport/index.json', encoding: "UTF-8"
    // Needed because the JSON is encoded in UTF-8 with BOM

    json = json.replace( "\uFEFF", "" );

    def xml_content = getJUnitXMLContentFromJSON( json )

    writeFile file: "${env.WORKSPACE}\\Saved\\UnitTestsReport\\junit.xml", text: xml_content.toString()
}

@NonCPS
def getJUnitXMLContentFromJSON( String json_content ) {
    def j = new JsonSlurper().parseText( json_content )
    
    def sw = new StringWriter()
    def builder = new MarkupBuilder( sw )

    builder.doubleQuotes = true
    builder.mkp.xmlDeclaration version: "1.0", encoding: "utf-8"

    builder.testsuite( tests: j.succeeded + j.failed, failures: j.failed, time: j.totalDuration ) {
        for ( test in j.tests ) {
            builder.testcase( name: test.testDisplayName, classname: test.fullTestPath, status: test.state ) {
                for ( entry in test.entries ) { 
                    builder.failure( message: entry.event.message, type: entry.event.type, entry.filename + " " + entry.lineNumber )
                }
            }
        }
    } 

    return sw.toString()
}

A few things to note again here:

UE4 outputs the JSON as an UTF-8 with BOM file. This caused the JSON parser to not be able to parse it. This is why I had to specify the UTF-8 encoding when I read the file content, and replaced the character “\uFEFF”
I had to extract the actual conversion of the json content to the xml output in a separate function with the attribute @NonCPS to avoid jenkins errors about serialization. More infos here. Also, not putting the attribute resulted in the XML to not have any closing tags. More infos here.
Because of security reasons, I had to manually approve signatures of functions which are used in this script. So, if you have execution errors related to security, go to the Script Approval section of jenkins and manually approve.

If everything goes fine, you should have a jUnit.xml file in Saved\UnitTestsReport, and the step

junit 'Saved/UnitTestsReport/junit.xml'

should process this file, and let jenkins show you the test result in your job page.

About the way you write your unit tests in UE4:

since the jUnit format only allows one <failure> child for each <testcase>, if your unit test spits out multiple errors, you will have to concatenate all errors into one FString you will pass to AddError (defined in FAutomationTestBase).
I’m not sure it’s very relevant to get the tests runned, but the flags I use in the test definitions are:

EAutomationTestFlags::ApplicationContextMask | EAutomationTestFlags::ProductFilter

Feel free to comment or to give your suggestions!

Multi-platforms UE4 game on Jenkins

Fri, 30 Mar 2018 00:00:00 +0000

In a previous post I quickly said we use Jenkins to automate our builds of our in-development game. I thought it would be interesting to explain the process, and share what I came up with our configuration file.

We use the git-flow methodology on our project. This means that whenever we develop a new feature, or want to fix a bug, we create a branch from the tip of develop, then push it on GitHub, where it is reviewed by the peers. If everything is OK, the branch is then merged in develop.

The problem with that approach, is that we often had cases where the game was broken because an asset would not be cooked anymore after some code change. Another common issue we had was that a specific platform was not compiling anymore because of compilation errors. We could have asked every member of the team to make sure that nothing is broken each time a pull request is created, but this would have obviously been a lot of lost time.

This is why we used a continuous integration tool, Jenkins, to do all those checks for us.

In summary, here is what we wanted Jenkins to automate for us:

for each opened PR: cook only the Win64 platform, compile all platforms
for the currently opened feature branch : cook and compile all platforms
for the develop and master branches: cook, compile, archive all platforms

First, let’s head to Jenkins and add a new job of type Multibranch pipeline. We have 2 kinds of branches we need to find on GitHub, which must trigger a job on Jenkins : Pull requests and some regular branches (develop and master).

We then need 2 Branch Sources entries to discover the branches:

Pull requests:

Notice the advanced clone behaviours section which will allow to not download the entire repository history, which will speed up the job, and lower the disk footprint.

Branches:

We keep the same clone behaviours section, we manually filter the branches we are interested in, in the filter section.

The last thing to setup is to tell jenkins where to find the Jenkinsfile, which is basically a configuration file written in Groovy. In our case, we use a scripted jenkins file (as opposed to a declarative jenkins file).

Without further ado, here is the last iteration of our jenkinsfile, with comments to explain some portions of the code:

env.PROJECT_NAME = "YourGameName"

// If the job to run targets a branch which is already being built, cancel the already running job
abortPreviousRunningBuilds()

def tasks = [:]

// Expose some properties in the UI of jenkins when we run the job manually
properties([
    parameters([
        string( name: "ROOT_ARCHIVE_DIRECTORY", defaultValue: 'V:/', trim: true ),
        booleanParam( name : "DEPLOY_BUILD", defaultValue: false )
    ]),
    buildDiscarder( logRotator( numToKeepStr: '1' ) )
])

stage( 'Check parameters' ) {
    try {
        if ( params.ROOT_ARCHIVE_DIRECTORY == "" ) {
            error "ROOT_ARCHIVE_DIRECTORY must be set !"
        }
    } catch ( Exception err ) {
        slackSend channel: 'jenkins', color: 'danger', message: "Build failed : ${env.JOB_NAME} (<${env.BUILD_URL}|Open>)"
        currentBuild.result = "FAILURE"
    }
}

/* 
Each platform will be built in parallel. Parallelize accross all the slaves
Better parallelize each platform than each pull request, to save time when only 
a few jobs are running
*/
[ 'Win64', 'XboxOne', 'PS4', 'Switch' ].each {
    tasks[ it ] = {

        env.BRANCH_TYPE = getBranchType( env.BRANCH_NAME )
        env.DEPLOYMENT_ENVIRONMENT = getBranchDeploymentEnvironment( env.BRANCH_TYPE )
        env.CLIENT_CONFIG = getClientConfig( env.DEPLOYMENT_ENVIRONMENT )

        String labels = getNodeLabels()

        // Some jobs must be executed exclusively on a dedicated node of jenkins
        node( labels ) {
            // Some nodes store the job workspace (and the UE4 installed build) 
            // in a different directory
            env.WORKSPACE = getWorkSpace()

            ws( env.WORKSPACE ) {

                // For shipping builds, clear to force a full rebuild + full cook
                if ( env.DEPLOYMENT_ENVIRONMENT == "shipping" ) {
                    deleteDir()
                }

                stage( 'Checkout' ) {
                    sendMessageToSlack( "Build started", it, "#0000FF" )
                    checkout scm
                }

                try {
                    // Always build manually the editor due to a bug: 
                    // using RunUAT does not always compile the UE4Editor-XXX.dll
                    buildEditor( it )
                    // Do the actual build cook run; All specialized work is handled here
                    buildCookRun( it )
                    sendMessageToSlack( "Successfully processed", it, "good" )
                } catch ( Exception err ) {
                    sendMessageToSlack( "Failed to process", it, "danger", "Reason : " + err.toString() )
                    
                    error "Failed to process " + it + " : " + err.toString()
                }
            }
        }
    }
}

// Run all tasks; We are done!
parallel tasks

// ------------------------------------//
// All the helper functions used above //
// ------------------------------------//

def getBranchType( String branch_name ) {
    if ( branch_name =~ ".*develop" ) {
        return "development"
    } else if ( branch_name =~ ".*release/.*" ) {
        return "release"
    } else if ( branch_name =~ ".*master" ) {
        return "master"
    }

    return "test";
}

def getBranchDeploymentEnvironment( String branch_type ) {
    if ( branch_type == "development" ) {
        return "development"
    } else if ( branch_type == "release" ) {
        return "release"
    }else if ( branch_type == "master" ) {
        return "shipping"
    }
    
    return "testing";
}

def getClientConfig( String environment_deployment ) {
    if ( environment_deployment == "shipping" ) {
        return "Shipping"
    }

    // release and development return Development
    return "Development"
}

def sendMessageToSlack( String message, String platform, String color, String suffix = "" ) {

    String full_message = message + " : #${env.BUILD_NUMBER} - ${env.JOB_NAME} - " + platform + " On ${env.NODE_NAME} (<${env.BUILD_URL}|Open>)"

    if ( !( suffix?.trim() ) ) {
        full_message += " " + suffix
    }

    slackSend channel: 'jenkins', color: color, message: full_message
}

// Manually build the editor of the game using UnrealBuiltTool
def buildEditor( String platform ) {
    stage ( "Build Editor Win64 for " + platform ) {
        bat getUE4DirectoryFolder() + "/Engine/Binaries/DotNET/UnrealBuildTool.exe ${env.PROJECT_NAME}Editor Win64 Development ${env.WORKSPACE}/${env.PROJECT_NAME}.uproject"
    }
}

def buildCookRun( String platform ) {

    // Dont archive for bugfix / hotfix / etc...
    Boolean can_archive_project = ( env.DEPLOYMENT_ENVIRONMENT == "development" 
        || env.DEPLOYMENT_ENVIRONMENT == "shipping" )

    // Cook if we want to archive (obviously) and always cook on Win64 to check PRs won't break
    Boolean can_cook_project = can_archive_project || ( platform == "Win64" )

    stage ( "Build " + platform ) {
        bat getUATCommonArguments( platform ) + getUATBuildArguments()
    }

    if ( can_cook_project ) {
        stage ( "Cook " + platform ) {

            // Some platforms may need specific commands to be executed before the cooker starts
            executePlatformPreCookCommands( platform )
            bat getUATCommonArguments( platform ) + getUATCookArguments( platform, env.CLIENT_CONFIG, can_archive_project )
            executePlatformPostCookCommands( platform )
        }
    }
}

def getWorkSpace() {
    return getWorkSpaceRootFolder() + getWorkSpaceFolderName()
}

def getArchiveDirectory( String client_config ) {
    return env.ROOT_ARCHIVE_DIRECTORY + env.PROJECT_NAME + "/" + client_config
}

def getWorkSpaceFolderName() {
    // Shipping jobs always run on the master node, in a specific folder
    if ( env.DEPLOYMENT_ENVIRONMENT == "shipping" ) {
        return "Jenkins_${env.PROJECT_NAME}_Master"
    } else {
        // Use same folder for PRs and develop since we now have multiple nodes working in parallel
        return "Jenkins_${env.PROJECT_NAME}"
    }
}

def getWorkSpaceRootFolder() {
    if ( env.NODE_NAME == "master" ) {
        return "D:/"
    }

    return "C:/"
}

def getNodeLabels() {
    // Do all shipping builds on master for storage purposes
    if ( env.DEPLOYMENT_ENVIRONMENT == "shipping" ) {
        return "master"
    }

    return "ue4"
}

def getUE4DirectoryFolder() {
    if ( env.NODE_NAME == "master" ) {
        return "D:/UE4/Windows"
    }

    return "C:/UE4/Windows"
}

def getUATCommonArguments( String platform ) {
    String result = getUE4DirectoryFolder() + "/Engine/Build/BatchFiles/RunUAT.bat BuildCookRun -project=${env.WORKSPACE}/${env.PROJECT_NAME}.uproject -utf8output -noP4 -platform=" + platform + " -clientconfig=" + env.CLIENT_CONFIG

    result += getUATCompileFlags()

    if ( env.CLIENT_CONFIG == "Shipping" ) {
        result += " -clean"
    }

    return result
}

def getUATCompileFlags() {
    // -nocompile because we already have the automation tools
    // -nocompileeditor because we built it before
    return " -nocompile -nocompileeditor -installed -ue4exe=UE4Editor-Cmd.exe"
}

def getUATBuildArguments() {
    // build only. dont cook. This is done in a separate stage
    return " -build -skipcook"
}

def getUATCookArguments( String platform, String client_config, Boolean archive_project ) {
    String result = " -allmaps -cook"
    
    result += getUATCookArgumentsFromClientConfig( client_config)
    result += getUATCookArgumentsForPlatform( platform )

    if ( archive_project ) {
        result += " -pak -package -stage -archive -archivedirectory=" + getArchiveDirectory( client_config )
    }

    return result;
}

def getUATCookArgumentsFromClientConfig( String client_config ) {
    // Do not cook what has already been cooked if possible
    if ( client_config == "Development" ) {
        return " -iterativecooking"
    }
    // but not in shipping; Do a full cook.
    else if ( client_config == "Shipping" ) {
        return " -distribution"
    }
}

def getUATCookArgumentsForPlatform( String platform ) {
    String result = ""

    // See https://docs.unrealengine.com/latest/INT/Engine/Basics/Projects/Packaging/
    if ( platform != "PS4" ) {
        result += " -compressed"
    }

    if ( params.DEPLOY_BUILD ) {
        if ( platform == "PS4" ) {
            result += " -deploy -cmdline=\" -Messaging\" -device=PS4@192.168.XXX.XXX"
        }
        else if ( platform == "XboxOne" ) {
            result += " -deploy -cmdline=\" -Messaging\" -device=XboxOne@192.168.YYY.YYY"
        }
    }

    return result
}

def executePlatformPreCookCommands( String platform ) {
    if ( platform == "PS4" ) {
        
    }
}

def executePlatformPostCookCommands( String platform ) {
    if ( platform == "PS4" ) {
        
    }
}

// Note you will have to add some exceptions in the Jenkins security options to allow this function to run
def abortPreviousRunningBuilds() {
  def hi = Jenkins.instance
  def pname = env.JOB_NAME.split('/')[0]

  hi.getItem( pname ).getItem(env.JOB_BASE_NAME).getBuilds().each{ build ->
    def exec = build.getExecutor()

    if ( build.number < currentBuild.number && exec != null ) {
      exec.interrupt(
        Result.ABORTED,
        new CauseOfInterruption.UserInterruption(
          "Aborted by #${currentBuild.number}"
        )
      )
      println("Aborted previous running build #${build.number}")
    }
  }
}

That’s a pretty big file, result of many weeks of iteration. It could be more consistent when using environment variables or function arguments, but at least it gets the job done for us :)

I hope you will find it useful. You can find that file here, along a few other scripts we use here.

Do not hesitate to comment, to give your suggestions!

Installed build of UE4 with console support

Sun, 28 Jan 2018 00:00:00 +0000

Unreal Engine 4, since the version 4.13, has in its kit a tool named BuildGraph, which they use internally at Epic to create the installed engine we can install from their launcher.

We are in the beginning of the port of our next game on consoles. Developing for console with UE4 requires, as you may be know, to build the game using the sources of the engine. What’s problematic is that the initial compilation time is really huge, opening the visual studio solution is slow, and every developer has to be aware of how to build the engine. Including artists or designers if they wish to deploy the game on the console to check how the game or a particular asset behaves…

To ease the development and allow us better iteration times, we thought of using BuildGraph to try to compile the engine with the support of the console platforms on our build server, and allow anyone on the team to use the engine as if they just had downloaded it from the Epic Launcher.

It turns out it is very possible, and very easy to do :)

The process is the same one we use to compile our game, and to check the pull requests we want to merge do not break the code or the assets.

We have a job on our Jenkins continuous integration server, which polls on the develop branch of the fork of the engine. Whenever a new commit has been pushed on that branch, the job is executed and two simple steps happen:

Checkout the branch locally
Run the build graph script through a call to a bat command

Pretty easy isn’t it?

About the second step, the documentation gives us the basic skeleton of the command:

BuildGraph -target="Make Installed Build [PLATFORM]" -script=Engine/Build/InstalledEngineBuild.xml -clean

And after a look at the default InstalledEngineBuild.xml you will notice that there are a bunch of options we can use to tweak the build. The first option being HostPlatformOnly which, when set to true, will unset the other platform flags:

<Do If="'$(HostPlatformOnly)' == true">
  <!-- Activate correct Target Platforms for host -->
  <Switch>
    <Case If="'$(HostPlatform)' == 'Win64'">
      <Property Name="WithWin64" Value="true"/>
      <Property Name="WithWin32" Value="true"/>
      <Property Name="WithMac" Value="false"/>
      <Property Name="WithLinux" Value="false"/>
    </Case>
    <Case If="'$(HostPlatform)' == 'Mac'">
      <Property Name="WithWin64" Value="false"/>
      <Property Name="WithWin32" Value="false"/>
      <Property Name="WithMac" Value="true"/>
      <Property Name="WithLinux" Value="false"/>
    </Case>
    <Case If="'$(HostPlatform)' == 'Linux'">
      <Property Name="WithWin64" Value="false"/>
      <Property Name="WithWin32" Value="false"/>
      <Property Name="WithMac" Value="false"/>
      <Property Name="WithLinux" Value="true"/>
    </Case>
    <Default>
      <Error Message="$(HostPlatform) is not supported for making an installed build"/>
    </Default>
  </Switch>
  <!-- Other Target Platforms always disabled -->
  <Property Name="WithAndroid" Value="false"/>
  <Property Name="WithIOS" Value="false"/>
  <Property Name="WithTVOS" Value="false"/>
  <Property Name="WithHTML5" Value="false"/>
  <Property Name="WithPS4" Value="false"/>
  <Property Name="WithXboxOne" Value="false"/>
  <Property Name="WithSwitch" Value="false"/>
</Do>

This lead me to this initial command :

bat "${env.WORKSPACE}/Engine/Engine/Build/BatchFiles/RunUAT.bat" BuildGraph -target="Make Installed Build Win64" 
    -script="${env.WORKSPACE}/Engine/Build/InstalledEngineBuild.xml" -set:HostPlatformOnly=true -set:WithDDC=false
    -set:WithPS4=true -set:WithXboxOne=true -set:WithSwitch=true

One hour and half later, when the compilation finished, I realized that the output folder did not contain any console specific files…

If you look at what is done inside the HostPlatformOnly block, you will notice that all the platform flags are Properties, with the same name as the Options in the beginning of the file. I suppose there is a limitation of the system which makes impossible to override a Property by an Option.

I then removed the HostPlatformOnly option, and manually set every platform flag we need to true, and the platforms we don’t need to false:

bat "${env.WORKSPACE}/Engine/Engine/Build/BatchFiles/RunUAT.bat" BuildGraph -target="Make Installed Build Win64" 
    -script="${env.WORKSPACE}/Engine/Build/InstalledEngineBuild.xml" -set:WithDDC=false 
    -set:WithWin64=true -set:WithPS4=true -set:WithXboxOne=true -set:WithSwitch=true 
    -set:WithWin32=false -set:WithMac=false -set:WinLinux=false -set:WithIOS=false 
    -set:WithAndroid=false -set:WithTVOS=false -set:WithHTML5=false

After an even longer compilation time (which was a good sign after all), I generated the Visual Studio solution file of our game, using that new Installed Engine as the source folder. And I was happy to see that the console platforms were correctly added to the project, and that I could deploy to the consoles directly from the editor.

You may find those links useful:

The second link in particular explains how to update the BuildGraph XML to add an extra parameter to set where the installed build files should be copied over, which is useful to export the engine in a shared location.