Realistic
Realistic Advanced Real-Time Collaboration and nDisplay Control Settings
GCC Academy
Network Basics for Multi-User and Switchboard Utilization
Hello
I am Park Ji-yong for today's lecture, Real-Time Collaboration and nDisplay Control Settings
In this lecture, we will build upon our understanding
of Perforce and nDisplay
to explore Multi-User and Switchboard,
focusing on their practical applications through hands-on exercises
The use of Perforce, nDisplay, Switchboard, and Multi-User
involves integrating multiple machines into a network-based system
Before diving into the main content,
we will briefly cover essential network concepts
required to operate these systems efficiently
The term network is derived from the combination of net and work,
referring to a system of interconnected computers, smartphones,
and data transmission devices, which we call nodes
A network is a data communication system
that enables several independent devices to communicate directly
within a suitable range through a physical communication channel at an appropriate speed
The exchange of data between nodes in a network is called communication
To enable this exchange,
the communication between computers, a protocol is required
A protocol is a set of rules governing data communication
When computers communicate over a network, they do so by exchanging packets via links
A link is the physical communication path between nodes, used for transmitting packets
A packet is a small unit of data that has been divided for transmission
The primary reason for using packet-based communication is this
By dividing data into smaller packets,
multiple computers or nodes can share and utilize information more effectively
An IP address stands for Internet Protocol Address
It is a unique identifier assigned to a node on a network
There are two major types of IP addressing systems: IPv4 and IPv6
IPv4 was the first Internet Protocol introduced in the early days of the Internet
It uses a 32-bit addressing system,
allowing for approximately 4.2 billion unique addresses
However, due to the rapid increase in Internet usage, IPv4 addresses have become insufficient,
leading to the development of IPv6
IPv6 uses a 128-bit addressing system,
which provides a lot of addresses, approximately 340 undecillion
This massive address space, a nearly infinite number,
allows IPv6 to accommodate the explosive growth of Internet-connected device
IPv4’s advantage lies in its relatively simple structure, making it easy to configure,
and the fact that it is widely supported by most websites and network environments
However, a major drawback is its limited address space,
which has already led to address shortages
In contrast, IPv6 provides an almost unlimited address pool
and supports the latest devices and protocols
IPv6 has a more complex configuration process, increasing the likelihood of errors due to incorrect settings,
and its long addresses make it difficult to memorize
Additionally, some websites and network environments
still do not fully support IPv6
IP addresses are classified into
static IPs, dynamic IPs, public IPs, and private IPs
Let's look into each
Static IPs remain fixed and do not change,
offering stability and security, which makes them suitable
for devices and servers requiring permanent addresses
Dynamic IPs, on the other hand, change periodically
and are mainly used for general internet users
Since assigning a fixed IP to every user is impractical,
dynamic IPs help optimize network resources
Public IPs are unique and globally recognized,
meaning they are assigned by ICANN, the international organization that manages IP allocations
In South Korea, the Korea Internet & Security Agency, or KISA, oversees these IP blocks,
which are then distributed to users by ISPs
A public IP address allows direct communication with external networks
A private IP address is used only within an internal network
Typically, ISPs assign a public IP
to a household or company network, and a router or network device
then translates it into private IPs
for internal use
Private IP addresses are only accessible within their designated local network
and cannot be reached from external networks
They are used to efficiently manage network resources
and enhance security
In summary, a static IP provides a stable connection that does not change and offers high security
A dynamic IP is mainly used for efficient network resource allocation,
making it common for general users
A public IP is globally unique and allows direct communication with external networks,
whereas a private IP is used exclusively within internal networks,
enhancing security by preventing direct external access
Now, let’s take a look at ports
A port is essentially a detailed address used by applications when sending and receiving data
To make this easier to understand, let’s compare it to a delivery system
When sending a package, you need a general address, such as a city and district,
which corresponds to an IP address in networking
However, you also need specific details like the apartment name, building number, and more
This specific information is analogous to a port
While an IP address identifies the location of a computer,
a port specifies a particular application within that computer
Port numbers are generally categorized into three types
The first type is well-known ports,
which range from 0 to 1023
These ports are reserved for standard services
For example, HTTP uses port 80,
while HTTPS operates on port 443
The second type is registered ports,
which range from 1024 to 29151
These ports are designated for specific applications and are officially registered for use
The third category is dynamic ports, ranging from 29152 to 65535
These ports are assigned dynamically and can be used freely as needed
Now, let’s examine how data is transmitted over a network
There are four primary methods of network data transmission
The first is unicast, a one-to-one communication method
used to send data directly to a specific recipient
The second is broadcast,
which is a one-to-all communication method
that transmits data to all devices on a network
This method is often used when the recipient’s exact address is unknown
and is commonly employed during network device discovery processes
The third is multicast, a one-to-group communication method
that allows data to be transmitted simultaneously to multiple recipients within a specific group
Lastly, anycast is also a one-to-one communication method,
but it transmits data to the nearest recipient among multiple devices
that share the same address
In summary, ports serve as detailed addresses for data transmission,
and network transmission methods are classified into unicast, broadcast, multicast, and anycast
These concepts form the foundation of networking
and are essential for various application services
Having covered the necessary networking concepts required
for using Perforce, nDisplay, Switchboard, and Multi-User collaboration,
we will now move on to a practical session to explore Multi-User and Switchboard functionalities
nDisplay and Collaboration Process Practical Exercise
Now, based on what we’ve learned so far, let’s proceed with a practical exercise
Let's start with the basics
All NDC systems rely on multi-device setups,
making data communication a key component
First, we need to disable the Windows Defender firewall
We will go into the firewall settings and turn it off
Additionally, I will check the firewall status of the render nodes
that I will be connecting to
Yes, same
It is disabled
Now,
just to recap,
though we already saw this,
let’s verify whether the IP address and connectivity of my render node are functioning correctly
Now that we checked,
let’s take a closer look at Switchboard
So we're going to look at Switchboard
Let me first explain briefly
Switchboard is a plugin that enables centralized control of multiple devices
It is primarily built using Python
and to communicate with other devices,
it works with Switchboard Listener,
which is a C++-based program
Switchboard is useful for various tasks such as Multi-User collaboration, nDisplay, and Take Recorder integration
Now, let’s take a look at its interface
Let’s start by launching Switchboard
At the top of the interface, you can define Sequencer, Slate, and Take Name
Just below that, you can add multiple devices
Once added, the device names will appear in the lower section
To the right, you can preview the Unreal Engine level that is currently being run through Switchboard
Below that, there is an option labeled Project CL,
which stands for Change List in Perforce
This allows you to view previous change lists
and switch between older and latest versions
There are several important buttons available
There is Refresh,
Sync,
Build, and Sync And Build
Refresh updates source information
Sync synchronizes all connected devices
to the selected version
Build compiles all connected devices
Sync And Build performs both synchronization
and compilation for all devices
Let me now start from the far right
The Listener Connection button turns blue
when a successful connection is established
Pressing the Start button will launch the associated devices
Switchboard also displays device names, IP addresses,
and allows easy modification of IP settings if a connection is lost
Additionally, when pressing this,
it provides an overview of change lists
The Change List at the top refers to the server’s Change List,
while the Change List displayed below pertains to the device’s Change List for synchronization
This one determines whether the connected devices will automatically join a Multi-User session upon startup
Let’s enlarge the Switchboard window to examine additional details
At this point, nDisplay-related components have been connected and synchronized
On the right side, we can monitor the overall status of the connected render nodes, including:
Device names and IP addresses
Graphics card versions
The Presenter Board within Switchboard specifically displays these details when nDisplay is running
It gives us the sync status
and the color bit depth
Sync status
Mosaic mode
Operating system version
Also, CPU,
memory, GPU utilization,
and GPU temperature
At the bottom, there is a log panel
where all real-time operations are recorded
This is the Multi-User Session name
The Multi-User session name is crucial
because it functions as a text-based identifier for establishing and maintaining connections
Now, let’s proceed to open Unreal Engine
Here it is
The previously tested project
from last class is loading,
and we will check on the Switchboard plugin
The Switchboard plugin is properly enabled
Now, we will navigate to the Launch Switchboard option
At the bottom of the interface, there is an option to launch the Switchboard Listener
Entering the Project Settings,
we can check the installation status of Switchboard
Mine has already been installed
If the installation is incomplete or an error occurs,
reinstalling it can be done by clicking the Install button
This process requires an internet connection,
as it fetches necessary files online
When the installation begins, Python-based setup
is executed automatically
After the installation is completed with a Finish message, we proceed
In my case, I have set up my Windows system
to launch the Switchboard Listener automatically upon startup
Once Switchboard is running,
it is essential to verify the correct path configurations before proceeding
The Workspace Name can be found
in P4V, specifically in the upper-left corner of the interface
That's the Workspace Name
The project exists locally
but hasn’t been synchronized with the server
It will appear as a blank white page icon,
indicating that the Switchboard cannot operate properly due to unsynchronized data
To resolve this, we return to Perforce
and synchronize the project
Here,
try the Revision Control system
We can enter like so,
but since Perforce is not currently connected, the Revision Control system is inaccessible
Let's recap on what we learned so far
First go inside P4V
Here, map the newly created Depot for integration
We're almost in
So here,
the project folder I created is named ndc_test
To ensure consistency, we will create a Depot with the same name
This time, we will create the Depot locally
Once created, we can find ndc_test list under the Depot List
Now that the Depot has been set up,
we will proceed with linking the Depot to a Workspace
and uploading the Workspace Data
This step is carried out within P4V
Upon entering P4V,
we need to map
the newly created Depot for integration
Check that,
press apply
OK
Once the mapping is complete,
just as we learned,
we select only the necessary files, Config, Content, and UProject, for upload
Clicking Add
and then Submit
starts the upload process
Before finalizing, we enter a description
To speed up this process, a 10GbE network is required
Now, at check ndc_test, the upload has been successfully completed
With this, the basic setup is complete
To verify everything, we proceed to Revision Control and attempt to establish a connection
We select Perforce, choose the appropriate Workspace,
and initiate the connection
Once the connection is established,
we check for the confirmation message before launching Switchboard
Next, we create a new configuration in Switchboard
A new config
Although we have checked this earlier,
we once again verify that the configuration name as ndc_test_v1
We also ensure that the UProject path is properly entered
Yes, looks alright
The next step is to confirm that
the Engine installation directory is correctly specified
Yes, that's a way to check it
Next is the most important Perforce-related patch settings
The patch path
must match
the depot name we just created,
which is NDC_test
So type in NDC_test here
For the workspace name,
as mentioned earlier, we can verify it in P4V,
either in the upper-left corner or under workspace settings
Once these details are correctly entered, we click OK to proceed
With the connection, the Switchboard interface appears empty
At this point,
we begin by adding devices one by one and testing them
First, we add an Unreal Engine device,
starting with the local machine before registering remote devices
Name the device main_10
and I will enter my own IP address
If we attempt to connect
while the Listener is turned off,
we encounter a Socket Error
The system cannot establish a connection without an active Listener
Let me restart the Listener
Once the Listener is active,
the device successfully connects, indicating that communication is properly established
Turn Unreal Engine off
Here,
now we can remotely control this
I disabled Auto-Join Multi-User Session
So this is how it works
The session can be closed by pressing X
With this setup, multiple Unreal Engine machines
can now be controlled simultaneously
Next, let’s add another device
The second device we will add is nDisplay,
which requires loading a config file
We will load the NDC config that was created in the previous session
After navigating to the correct directory,
we select the saved config file and,
instead of clicking OK immediately,
we first press the Propagator button to process the file
Once this step is completed, we proceed by clicking OK
This successfully adds nDisplay,
and we can see the render node’s IP
However, upon attempting to connect, an error appears
It says that the change list
is not being detected on the render node,
even though the main machine is working correctly
Let's solve this together
Navigate to the Settings menu, where all core configurations are managed
Within the settings,
we access the nDisplay-specific configurations
and check the workspace name
The main machine is set
to main_10,
but the render node’s workspace has a different name
To check, go under the VNC session
Same thing here
We can check it with P4V
The left top corner of P4V confirms
that the render node’s workspace name is render_20
After inputting the correct workspace name and attempting to reconnect,
the error still persists
This suggests an additional issue
Now, while Switchboard settings are correct,
we forgot to do one thing
It is that the render machine has not yet received the project files
Here,
it is at depot,
but not in Workspace under Render Node
So we need to connect it gain
by mapping the depot correctly,
click on the target depot,
and initiate synchronization
Since the project is relatively small, the sync completes quickly
Now, both the main machine
and the render machine contain the same files
We see that the nDisplay monitor successfully loads all render machine settings
Once the connection is established, the nDisplay monitor
will correctly display all settings related to the render machine
Entering the Settings menu,
we need to adjust a few key configurations
First, in the Multi-User Server settings,
we have the server name matches the system device name
Below that, in the Multi-User Server section, there are a few settings that need to be modified
First, the Server Name
must match the system device name of the machine
Next, we disable Auto-Launcher and UI Mode
Then, in the nDisplay settings,
we enter the Unicast Endpoint
Although we haven’t entered the LiveLink Preset yet,
this setting will be required later
when incorporating tracking data for real-time synchronization
Let's reset
Now, instead of setting up nDisplay,
we will add each machine as an Unreal Device individually
However, an error occurs again
Go into Settings
and modify the Workspace Name
to render_20
Enter the Unicast Endpoint as well
Let's connect again
Yes, it works alright
Now, let’s take a look at Multi-User functionality
First, we enter a Session Name
and enable Auto Join
Once this is set,
clicking the Start button will launch the Multi-User Server
At this point,
the server is up and running,
and the session name we just entered
allows two computers to connect
Above the Auto Join option,
we can see the Multi-User Server
and the assigned IP address for the session
Multi-User functionality enables
simultaneous collaboration
on level design across multiple machines
Now, we proceed to launch the Unreal Project
The current view shows the main computer
When we open the Multi-User Browser,
we can confirm that both the main computer and the render machine have successfully joined the same server
Next, let’s explore how this works
by splitting the screen, the main computer on the left
nd the render machine on the right
Both are running the same project,
but there might be a slight delay
since the render machine is connected remotely
Now, let’s move the main machine to the left
and the render machine to the right
We’ll test this by moving an actor within the scene
When we move the NDisplay,
we can see that the render machine on the right,
which is a separate computer, reflects these movements in real time
This real-time synchronization is
the key advantage of Multi-User Editing
The camera moves smoothly,
and if we check the history log,
we can see a record of every action taken,
including which client
moved which object
at what time, all recorded like so
Now, let’s test this from the render machine side
Moving an object from the render machine updates the main machine in real time
This feature not only enables multi-user editing
but also integrates seamlessly
with NDC, supporting various functions
Since we entered the session name earlier, we can confirm that both machines
have connected to the correct session
Now, let’s disconnect from the main machine
Here,
moving objects
no longer updates across machines,
confirming that the synchronization stops when leaving the server
If we scroll down,
we can still see the created session,
which can be rejoined at any time by clicking on it
At this point, we will exit the session
What I've just demonstrated
is how multiple Unreal devices
collaborate in a multi-user editing environment
Next, we’ll show how one machine acts as the main operator,
while the other functions as an NDisplay device
The concept remains identical
We enter a session name
and start the server
Once this runs, we can see that
the NDisplay monitor on the right
will display a separate status panel
Here
First, the percent mode updates correctly,
indicating proper operation
Moving to the right,
we can also monitor GPU usage in real time
Returning to the main operating computer,
we can confirm that it reflects the same data
At render machine,
hold on, let the change the screen size
So this is the final image output being displayed
This image represents what would be projected onto an LED wall
While we are currently viewing this on a monitor,
think of this as the final output being displayed on an LED screen
Here,
I just moved the ball and it disappeared
Switching to a split-screen view,
we can see that NDisplay movements
and actor adjustments
all synchronize in real time
This ensures that camera tracking movements
are applied to all render machines simultaneously
If we modify lighting,
add actors, or make other adjustments,
all changes are instantly reflected across all render machines
This real-time ICVFX functionality
is a crucial aspect of the system
Let's exit
Next up, let's try this
we’ll add Live Link,
though we don’t have an active source at the moment
But we can at least test this
We can see that it’s receiving data but not displaying anything,
as no external camera tracking data is currently available
Live Link always requires a preset,
which we typically store in the VP folder under the Live Link directory
We create a separate preset like this,
and if we assume this to be a camera tracking source,
to the camera actor,
we would apply Live Link Control
Here, we assign it the correct tracking data source
Since no data is being received at the moment, nothing appears,
but this is how it would be set up
Additionally, under Project Settings,
we have the Live Link tab
and we can configure the default Live Link preset
We will now add this preset to the project settings
By adding this, the project will automatically load the correct Live Link preset each time it runs
Next, we proceed with checkout
and then submit the changes
Once this is done,
return to Switchboard,
and we can see that the Change List has been updated
For the NDisplay nodes, we must configure them to load the same Live Link preset
I just set this part up
This setting can be found
under NDisplay settings
Come down a little
When launching this node,
you can specify which Live Link preset to load
Here, select this
and the preset that we created earlier for camera tracking
Once you select it,
you can run the system,
and the preset I have made should load correctly
The most crucial aspect of all this is
ensuring that all controls and settings on my main computer
are correctly and consistently applied to the render nodes
Up to this point, we have covered the overall concepts
and practical exercises for utilizing nDisplay in ICVFX
As you go through hands-on exercises, you may encounter various errors and bugs
However, troubleshooting and resolving these issues one by one will deepen your overall understanding of the system
Now, let’s summarize what we’ve learned in this session
Thank you
Basic Networking for Multi-User and Switchboard Utilization Network: communication structure with interconnected nodes Nodes: computers, smartphones..
Communication: The exchange of data between nodes Protocol: A set of rules used for data communication Link: A physical communication path
Packet: A small unit of divided data IP Address: A unique identifier assigned to nodes within a network
IPv4 A 32-bit addressing system: 4.2 billion unique addresses Simple structure and easy configuration
Due to the rapid increase in internet usage, address shortages have become a major issue
IPv6 128-bit addressing system: 340 undecillion addresses Supports modern devices and protocols, Complex and likely to have errors
Static IP: Fixed, secure, and stable Dynamic IP: Changes as needed for efficient resource use
Public IP: Globally unique, allowing direct external communication Private IP: Used within internal networks for security
Ports A specific address for data transmission in applications Well-Known Ports (0–1023): Reserved for standard services HTTP: 80, HTTPS: 443
Registered Ports (1024–49151): Assigned to applications Dynamic Ports (49152–65535): Used flexibly
Network Transmission Methods Unicast: One-to-one communication Broadcast: One-to-all transmission
Multicast: One-to-group transmission Anycast: One-to-nearest communication within a group
NDisplay & Multi-User Setup Switchboard Controls multiple remote devices in Unreal Engine Works with Switchboard Listener
Switchboard Listener: C++ app for Multi-User, NDisplay, and Take Recorder
Launch Switchboard & Verify Listener Perforce Configuration Create a Depot (NDC_test)
Link and upload workspace data in P4V Map NDC_test_uproject to NDC_test_Depot
Upload Config, Content, and UProject Submit, Changelist Description, Submit
Revision Control, Set provider to Perforce Assign workspace main_10
Create Config File Name: NDC_test_v1 Input correct Unreal Engine installation path Ensure Depot name matches Perforce settings
Ensure project patch matches the Depot name Workspace name must match the name displayed in P4V’s top-left corner
Adding Devices Unreal Device Add device → Select Unreal Device Register main PC as main_10 Enter current IP address
NDisplay Add device → Select NDisplay Load test_NDisplayConfig.uasset Click Populate, then confirm with OK
Render Node Configuration Change workspace name to render_20 Edit workspace settings to map render_20 to NDC_test
Click Sync on NDC_test Depot
Multi-User Session Set session name as test1 Enable Auto-Join Split screen: Main on left, Render on right Verify real-time sync between the two
Live Link Setup Create Live Link Preset Inside Content → 0_vp → Live Link, create CameraTracking_LiveLinkPreset
Go to Edit → Project Settings → Live Link Set default Live Link Preset to CameraTracking_LiveLinkPreset
Check-out → Submit Update Changelist Assign CameraTracking_LiveLinkPreset in NDisplay settings