Realistic Advanced nDisplay Multi-Display Setup
GCC Academy
Understanding nDisplay
Hello, everyone
My name is Jiyong Park, and I’ll lead today’s lecture
on nDisplay Multi-Display Setup
In this session
we’ll learn about nDisplay
As displays become larger and more diverse
it’s increasingly important to connect and reproduce
multiple displays effectively with scalability
So, after covering some basic theoretical concepts
we’ll go through a simple hands-on session
to see how nDisplay setups
are actually implemented in real-world scenarios
Let’s dive into Unreal Engine’s nDisplay
The "n" in nDisplay can be interpreted in several ways
"Network," as it represents a system where multiple computers and displays
are connected via a network, collaborating seamlessly
Through the network, data synchronization
real-time rendering, and output are achieved
aligning with this interpretation
Another interpretation is "Numerous,"
as "n" in mathematics commonly signifies an arbitrary number
In nDisplay, it symbolizes the system’s capability
to manage multiple displays or multiple nodes
highlighting its scalability and flexibility
Another interpretation is scalability
In line with the earlier points, "n"
suggests a system that can expand without limits
nDisplay allows additional displays and computers
to be connected
enabling it to operate flexibly even in large and complex environments
When we combine all these aspects
the essential characteristic of "n" in nDisplay symbolizes
network-based multi-display scalability
This highlights the technology's
flexibility and scalability
Let’s now take a closer look at the key features of nDisplay
Building on the concepts discussed earlier
nDisplay is a powerful multi-display system
in Unreal Engine
primarily used to configure and manage
large-scale display environments efficiently
This system delivers robust performance
even in complex multi-display setups
through four key features
The first major feature is multi-node rendering
nDisplay clusters multiple computers
to distribute workloads
Each computer processes its assigned display portion
collectively creating a unified, seamless scree
This distributed rendering effectively handles complex graphic calculations
enhancing overall performance
The second feature is network-based synchronization
nDisplay ensures perfect sync across all displays
and computers within the cluster
Frame sync and input sync prevent screen flickering or desynchronization
between rendering machines
in a multi-display environment
The third feature is the integration of camera and tracking systems
nDisplay supports various tracking systems
used in virtual production
In LED Wall setups, real-time camera tracking
adjusts the screen to match actors' movements
and filming equipment
This seamless synchronization between the physical and virtual environments
s crucial in enhancing immersion
Lastly, nDisplay offers flexibility in display configuration and management
It can be easily applied to rectangular displays
as well as various other shapes
Using tools like nDisplay Config and Switchboard
you can intuitively manage display layouts, resolutions
and cluster nodes
To implement nDisplay
both hardware and software elements are essential
These components must work together seamlessly
to establish nDisplay environment successfully
Let’s delve into the details
Starting with the hardware components
A high-performance hardware setup is essential for nDisplay
which requires the following elements
nDisplay relies on NVIDIA
with Quadro Sync cards being a mandatory component
These cards enable precise frame synchronization
across multiple displays
Next is Genlock input
The same Genlock signal must be applied
to all devices, including LED walls and cameras
Genlock synchronizes timing across clusters and nodes
preventing screen flickering or misalignment issues
Without proper Genlock configuration
nDisplay is technically unfeasible
Next is a high-speed network
All cluster nodes
must be connected to the same network
For optimal performance, a network speed of
at least 10Gbps is recommended
Low network latency
is critical to ensure smooth data transmission between clusters
Now, let’s examine the software components
Operating nDisplay requires specific tools and configurations
within Unreal Engine
The first is the nDisplay config file
The most critical element
for defining the cluster
This file specifies render nodes, display positions
esolutions, and synchronization settings
The cluster will only function correctly
if the config file is accurately written
The second tool is Switchboard
It controls multiple nodes simultaneously
It simplifies tasks such as
starting, stopping, and restarting the cluster
The third is the multi-user functionality
It is essential for collaborative work
in nDisplay environment
This feature allows multiple users to
edit and test elements in real-time across nodes
To successfully implement nDisplay
the correct combination of hardware and software is crucial
By utilizing Genlock, network synchronization, config file creation
Switchboard, and multi-user functionality
you can build a stable and consistent
multi-display environment
In summary, nDisplay is a system that leverages Unreal Engine
to construct and manage multi-display environments effectively
The operating principles of nDisplay involve the following steps
First, configuring the nDisplay Config File
First, create the nDisplay config file
and define the cluster environment
This file includes details such as the roles of each node, display settings
and network configurations
To ensure accurate settings, refer to the config reference
provided by Unreal Engine
and input each item precisely
Since each entry functions
as a critical command
it is essential to understand the purpose of every item in the file
Second, setting up network connections and synchronization
Connect all nodes and displays to the same network
and configure synchronization settings
This ensures that all nodes operate in unison
with frame and input synchronization
Third, nDisplay plugin
and basic project settings
Activate the nDisplay plugin in Unreal Engine
and configure the project
At this stage, check the nDisplay-related settings
and apply additional plugins
or configurations as needed
Fourth is execution and debugging using switchboard
Use Switchboard to execute
and debug the cluster
Switchboard enables simultaneous control of multiple nodes
and monitors their status
Through this process, nDisplay
operates effectively in virtual production environments
Next, consider important factors when using nDisplay
such as how many nodes to configure
and how to set the resolution
These configurations are based on
thorough calculations
The nDisplay config
does not merely remain at the software level
it directly affects
hardware commands
closely tied
to the hardware configuration and quantity
The criteria for these settings depend on
the LED panels' specifications and the LED volume's size
For example, let’s assume an LED Wall
with a width of 14m and a height of 6m
built using Ruby 2.2 panels from ROE
Ruby 2.2 panel is 50cm wide and 50cm high
with a resolution of 448×448 pixels per panel
For the entire LED Wall, a width of 14m
translates to 6,272 pixels
and a height of 6m corresponds to 2,688 pixels
Considering that each render machine or node can output
a maximum resolution of 3840×2160
covering the entire output of the LED Wall
would require
a total of 3 render nodes
Of course, as shown in this example
it is also possible to use only 2 render machines
However, in this case, the vertical resolution
would fall short by 528 pixels
Since render machines are extremely expensive
in scenarios where ultra-high resolution isn’t critical
slightly reduced resolution may be acceptable
The specific nDisplay configuration depends on
hardware scale, budget, and intended use
As mentioned earlier, nDisplay
is a powerful tool for
expanding and synchronizing real-time content in large-scale display environments
However, to use it effectively
it is crucial to understand its technical limitations
and take appropriate measures clearly
One of the most critical elements in an nDisplay setup is
as repeatedly emphasized, Genlock
Genlock is essential for ensuring
precise timing across
all displays, cameras, and cluster nodes
If Genlock is not properly configured
the following issues may arise
First, because of frame misalignment
the display may not connect smoothly
Second, because of timing mismatches between displays
it can lead to screen flickering or visual artifacts
To prevent such issues, it is necessary
to install NVIDIA Quadro Sync cards
or similar synchronization devices on each node
To solve the Genlock synchronization problems
there are numerous opinions
When encountering issues related to Genlock
due to the numerous causes
resolving them is note easy
Especially during the initial setup
everything may seem to work fine
but Genlock issues often surface
unexpectedly later
Over time, synchronization may drift
In some cases, problems might resolve independently without any specific action
This highlights the importance of
accumulating troubleshooting experience
through hands-on practice
nDisplay operates through real-time communication
between cluster node
making network performance
a critical factor in determining system stability
The recommended network bandwidth is at least 10Gbps
If network performance is insufficient or latency is hig
significant issues may arise
For example, data loss between clusters
can result in inconsistent display output
Additionally, frame mismatches
or rendering delays may occur
The best way to address these issues
is to involve someone with a strong understanding of network systems in the setup process
However, even if someone is well-versed in networking
they may lack specific knowledge about
the configuration and roles of nDisplay nodes
This makes collaboration essential for successful implementation
Key considerations include ensuring
all cluster nodes are connected to the same network
and using a dedicated network switch
To optimize the network, it is important to reduce unnecessary traffic
prevent packet loss between nodes
and thoroughly check firewall settings
Next, let’s discuss the software and system limitations
nDisplay operates based on
Unreal Engine's deterministic systems
However, some features of Unreal Engine
do not exhibit completely deterministic behavior
For instance, complex simulations such as physics engines, rigid bodies
soft bodies, and skeletons
may encounter synchronization issues due to rendering factors
For example, when using Niagara in a previous project
rendering timing varied across render machines
This was resolved only after
disabling certain non-deterministic rendering settings
Similarly, non-deterministic blueprints
that include random elements
can cause inconsistencies between nodes
To address these issues, projects involving
complex physics or rendering elements
should enable replication settings
Additionally, key simulation data should be calculated on the primary node
and distributed to the cluster nodes for consistent processin
Next, nDisplay can encounter issues
when handling rendering boundaries between multiple displays
Screen-based effects such as Bloom, Motion Blur
and Anti-Aliasing may cause
inconsistencies at the display edges
To resolve this, post-processing effects should be minimized
or disabled
Special caution is needed
when using effects like Bloom, Lens Flare
Motion Blur, and Ambient Occlusio
nDisplay is well-suited for large-scale projects
but not inherently for all types of content
As a result, users must manually distribute
project files to each node
or use specialized distribution tools
Unreal Engine addresses this
by enabling project synchronization
between nodes through Switchboard and Listene
Accurate synchronization requires
precise config file settings
Additional considerations include
the risk of node failure disrupting the synchronization
of the entire cluster in nDisplay system
Therefore, operating a monitoring system
to detect and quickly recover from node failures is essential
his risk increases with larger volumes
and a greater number of nodes
Properly assigning responsibilities and ensuring thorough management are crucial
Using Switchboard
the status of each node can be continuously monitored
When issues arise
logs should be checked immediately
As such, nDisplay is a powerful but complex technology
To optimize and use it efficiently
all potential issues across hardware, software, network, and content development
must be anticipated and addressed in advance
How to Create Config
Now, let’s proceed with nDisplay hands-on practice session
We’ll go step by step
So feel free to follow along
For this session, we’ll be using
Unreal Engine V5.3.2
Let’s start by launching it
Here, we’ll use one of
the standard setups provided
Let’s select Blank as our project template
Make sure to exclude Starter Content
Since the Perforce integration
is set to the D drive’s Perforce folder
we’ll maintain that path and name the project ndc_test
Next, click Create
To do NDC
you'll need to configure the basic project settings
The first step is to adjust the Plugin Settings
Since we’ve opened
a sample project related to in-camera VFX
most required plugins are already enabled, but let’s verify them
Scroll down until you see
the Virtual Production tab
Click on it to explore the plugins
we’ll be using
From here, I’ll go through and enable the ones I typically use
one by one
Enable the Camera Calibration plugin
Although we often use DMX
we’ll skip it for now
Next, turn on the ICVFX plugin
And there are LED Wall Calibration
Level Snapshots
and the related LiveLink plugins
The specific depends on the tracking equipment used
So, LiveLinkCamera, FreeD
I'll set like this
These settings are typically used for local testing
Let's enable it
As you scroll further, you’ll find the Stage Monitor
which helps monitor the performance
of connected machines
Also, Switchboard
Sync, and Data Monitor
enable these like this
After this, check
whether Multi-User Edition
and Take Recorder are enabled
Once all these plugins are set
restart the project
When the plugin setting is done
Let's proceed to the Project Settings
Many customizable settings exist
but today, we’ll focus on
the most basic ones
In the Input section
locate the Always Show Touch Interface option under the Mobile category
Make sure to disable this setting
If not
when you run NDC, circular touch interfaces
will appear on the left and right sides of the screen
Next, the most critical setting is the UDP Configuration
I currently have several IP option
As mentioned earlier, 127.0.0.1 is the internal loopback address
192 is the internal network I’m currently using
20.20.0 is my configured
internal internet network
I’ll use this
It’s recommended to input the Unicast address accurately
Another setting is Multi-User Editing
Enable the Toolbar Button here
and set the Server Type to Console
These are the basic Unreal Engine settings
but remember that many additional configurations are required in Window
before running NDC
I'll be using two computers for this setup
One will handle the main operating tasks
which is my current computer
he other will serve as the render node
responsible for executing
NDC operations
To configure these two systems
for a multi-computer setup
we’ll use the nDisplay Config file
what we often abbreviate as NDC
While the NDC is the primary configuration file
additional settings need to be applied
to the render machine before proceeding
Let’s go ahead
We’ll make these adjustments through VNC
As you can see, this is the remote computer
The first step is
configuring the graphics card settings
All the necessary basic settings can be checked
in the System Topology
and we’ll adjust them one by one
In 3D Settings, I’m using Workstation’s
Advanced Streaming mode
Additionally, ensure that
the Power Management Mode is set
to Prefer Maximum Performance for optimal operation
On this machine
we have two NVIDIA RTX A6000 cards
installed
These are connected to an image processor
Tessera SX40
To optimize and enhance performance
the two cards are linked via SLI configuration, allowing them to work together
Our resolution is 3840×2160
with a refresh rate of 24fps
Make sure to set the refresh rate to 24Hz
Once this is complete
click on Display Synchronization
As I’ve emphasized
Genlock is the most critical aspect of NDC
Here’s how to set it up
Since we’re using only one
external Genlock signal source
click on the system
In my case, I’ve connected
the external house sync signal
so I’ll select it, apply
and confirm
Since we’re working with two computers
both must be connected to the same network
To verify
let’s check the main computer’s IP address
It’s 20.20.0.10, and when we go back to VNC
it has an IP address of 20.20.0.20
So, let's send a pig from here
When we send with the main machine
the ping will be successfully connected
Basic settings are done
For additional verification
go to the network settings
and check
the status of the used internal network
Since I set this for 10Gbps
you can see the speed is confirmed as 10Gbps
It would be a good idea to configure your network
in this way to over 10Gbps
A typical external network is 1Gbps
Setting Up nDisplay Config
Now, let’s configure the NDC file
We’ll work with a blank project
to ensure a clean setup
First
Create Folders and Paths
Since this setup is not done alone
rather often done in collaboration with others
it’s highly recommended to use
a consistent and well-defined folder structure
Accuracy in folder paths is critical
Create a folder in the Content folder
Create a new folder named vp, and inside, create the following subfolders
First, livelink
Second, NDC
Finally, oCIO
Although there are additional folders
we’ll focus on the basic setup for now
To begin setting up the NDC
Right-click
and go to nDisplay - nDisplay Config
When you click here
you can import an existing configuration
or create a new one
For this session, we’ll create a new one
Name the file
Give the file a meaningful name
Proper naming is crucial for collaborative work
ensuring clarity and avoiding confusion
Let's open the Config file
When you open the newly created Config file
a predefined UI interface will appear
I'll just overview it
At the top
you’ll see a set of basic functions
commonly used in Unreal Engine
Bluepring - Components - Cluster
Preview
And for the final output mappings
there is Mapping Window
On the right-hand side
you’ll find the Details pane
Here'e basic parts
I'll add this
As mentioned in the lecture, the mesh file is particularly important
The configuration varies significantly depending on the file you choose
This is the website I use the most
When you enter the basic panel informtion
LED Wall information
it export it as an OBJ file
For example, 10m x 4m
Tile Angle means angle for individual LED panels
I'll set it to 2 degrees
And 500x500 for width and height per nael
Resolution 192
x 192
Set Position Offsets
and the Pivot Point in the tool as needed
And click download OBJ
We can confirm basic
OBJ file like this
Create a new folder
mesh folder
Import the downloaded OBJ file into the mesh folde
There are a variety of settings you can configu
but today I will just keep it simple
with the default values
Let’s go back to the NDC
Now, we need the LED mesh we'll be using
We'll import
the mesh here
You might notice that it doesn’t display properly
likely due to scale differences
You can adjust the scale
in the Details panel to fix this
Once the scale is set
you’ll see the grid floor with meter measurements
Here's plus, minus
The part facing you is the front, which will act as the front-facing direction
Next, it’s important to set the distance accurately
This distance is based on
the origin point of the tracking data
For example, if the tracking data’s origin
is 8 meters away
you need to set this to 8 meters
This process aligns the origin of the virtual world
with the real-world origin
Finally, add nDisplay Transform
write it down
and an ICVFX Camera
With these steps, the basic configuration is complete
Next, after adding the Origin
you can assign it to a specific cluster or node
for rendering
Since we’re working with just one node
let’s create it now
Name it main_wall_node
set Cluster as the Parent, and adjust the Preset settings
If you look here, you can adjust this here
Since we are basically
set 3840×2160 per output
please enter 3840×2160
Here you need a Host IP
for this IP you can enter the IP of the node
in the render machine you created earlier
And it should always be Fullscreen
so you can check this to make it
There are additional settings
but I'll tell you about them next time
So, if you click Add
it will be added to OutputMapping
If you look here, you can check the resolution
and the IP address of the render node
If you look at it now, you will see a black screen
Since the mesh setting for where this mapped image
will appear has not been done
it is black
If you look at the Projection Policy, select the mesh
and the mesh we created will be here
If you click on it, the mapping will be like this
However, the mesh of the LED Wall that we will actually use
is 3840 because it contains two 192-resolution panels of 10m each
and the height is 192 times
2 panels, so 2 times
4m is 1536
Therefore, this 3840 is the same
but this 1536 needs to be changed
Here, change this
to 1536
If you look at it
you can see that
it can output as 1:1 pixels
If you look at it, we can explain
a few more things here
First, these parts
are meaningful when there are
multiple render machines
But let me briefly explain a few important parts
Basically, the Render Sync Policy here
is set to ethernet as the default setting
But the better setting in terms of performance is Nvidia
You can select this
when using multiple renderers
This plays a big role in increasing or decreasing
the graphics card's performance
When you're done, click Compile and exit
Now, what you need to do additionally in this state
is to upload the NDC Config here
When you do this, nDisplay will appear
and you can check the part formed on the screen
the outer frustum, and the inner frustum
If you look, it looks like this
In my case, I add one basic actor
and set this guy to ndc_origin
So I put this guy under here
I tend to adjust the NDC position value
through the origin like this
When you've reached this point, there's something else you need to do
As a result, you need a separate camera
to play this inner role
For that camera
click Cine Camera Actor in Cinematic
and add an actor
Likewise, put this actor
under nDisplayConfig
In my case, I additionally
created acamera_origin
and put the camera actor on the right
After that, I always return the origin
to the origin
This is because some directors
want to change the inner position slightly
but if it is tied to tracking data, it cannot be adjusted
So I adjust it through this origin
If you have reached this point, you need to set the camera in NDC
If you look, I set this inner ICVFX Camera
in the inner NDC earlier
Click on it
and then click on which camera actor you want to assign to this role
and the assignment is complete
For example, if you move this camera
the inner will change like this
If you put in a few for testing
you can see that the shape of this guy holding the inner camera
has just changed like this
Now, these are the basic NDC settings
In addition, the core elements of NDC are
First, CIO
Second, light card
Third, chroma settings
here are many various and detailed settings
so I think it would be good
to study them additionally on your own
This concludes
today's lecture on
nDisplay multi-display setup
nDisplay plays an important role
in virtual production
I hope that the basic theory and practical content you learned today
will be helpful in applying it to actual projects
and lead to stable results
There may be many technical challenges
in utilizing nDisplay
but the results are equally rewarding
Then, let's finish by reviewing
what we learned this time
Thank you
Understanding nDisplay nDisplay Unreal Engine's powerful multi-display system is used to configure and control large-scale display environments efficiently
Key features of nDisplay Multi-node rendering Network-based synchronization Integration of cameras and tracking systems Flexibility in display configuration and management
nDisplay hardware components NVDIA Quadro Sync card, Genlock support, high-speed network
nDisplay software components nDisplay config file, SwitchBoard tool, multi-user functionality
nDisplay How It Works Step by Step Configuring the nDisplay config file Setting up network connections and synchronization
Configuring the nDisplay plugin and basic project settings Running and debugging with SwitchBoard
Limitations of nDisplay Genlock and synchronization issues Network performance limitations
Limitations of deterministic systems Problems with rendering boundaries between multiple displays Limitations of content development and distribution
How to create a Config Plugin Settings Select Virtual Production, Camera Calibration, ICVFX, Led Wall Calibration,
LevelSnapshots, LiveLinkCamera, LiveLinkFreeD, nDisplay Launch, Stage Monitor, Stage Monitor with the installed plugins
Check the activation of Multi-User Editing, Take Recorder
Project Settings Uncheck Engine - Input - Mobile - Always Show Touch Interface
Plugins - UDP Messaging - Transport - Unicast Endpoint
Plugins - Multi-User Editing - Activate Toolbar Button Server Type is set to Console
Render machine actual execution part settings Set power management mode to prefer highest performance in F3D settings management Check maximize 3D performance in SLI and PhysX configuration settings
Set resolution to 3840×2160, refresh rate to 24Hz and select display synchronization Select this system item in timing server, then select external house sync signal, then apply and confirm
Set the network of the two computers being used to be the same, and set the speed to 10Gbps or more
nDisplay Config Setting Create a new folder in the Content folder and name it 0_vp
Create new livelink, ndc, and ocio folders in the 0_vp folder Select Create New Config in the ndc folder and name it test_nDisplay Config
Enter LED Wall information in ObjGen [beta] and click Download OBJ Create a new mesh folder in the ndc folder and drag and drop the obj file to the mesh folder
Register the obj Mesh in the mesh folder as a component of test_nDisplay Config
Add NDisplay Transform, ICVFX Camera, and NDisplay View Origin components
Add Cluster Node and name it main_wall_node Set the resolution to 3840×2160, IP address to the same as the render machine, and check Fullscreen
Change the Type of Projection Policy in the Details window to Mesh and apply obj mesh to Mesh
Change the size of main_wall_node and VP_0 to fit the panel size