nDisplay Overview

Describes how multiple computers work together in an nDisplay rendering network.

Choose your operating system:

Windows

macOS

Linux

On this page

nDisplay Components
Runtime Camera Control
Blueprint API
Extending nDisplay

Every nDisplay setup has a single master computer, and any number of additional computers.

Each computer in the network runs one or more instances of your Project's packaged executable file.
Each Unreal Engine instance handles rendering to one or more display devices, such as screens or projectors.
For each of the devices an instance of Unreal Engine handles, it renders a single viewpoint on the same 3D scene. By setting up these viewpoints so that their location in the 3D world matches the physical locations of the screens or projected surfaces in the real world, you give viewers the illusion of being present in the virtual world.
The master node is also responsible for accepting input from spatial trackers and controllers through connections to Virtual-Reality Peripheral Networks (VRPNs), and replicating that input to all other connected computers.

The image above shows a possible nDisplay network. Like all nDisplay networks, one of its PCs acts as the master node. This master node accepts input into the system from a VRPN server, which relays signals that come from spatial tracking devices and other controller devices. The network also contains several other PCs that run other instances of the Unreal Engine Project. Each of these cluster nodes drives one or more display projectors.


	One application instance that renders to one display device. This is the most straightforward way to set up a host for nDisplay. For each projector or display device you need, you set up one computer to handle rendering to that device. On that computer, you run one instance of the Unreal Engine. Typically, in this scenario, you'll set up that application instance to render a single rectangle of 3D space into a single viewport.
	Multiple application instances that each renders to one display device. If you have computers in your network that have multiple graphics cards and that can handle driving multiple display devices, you can run multiple instances of the Unreal Engine on those computers. You'll direct each instance of the Unreal Engine to render a different rectangle of 3D space, and dispatch each to a different graphics card. This approach can work well if the CPU and memory requirements of your Project are light enough that you can run multiple instances on the same computer.
	One application instance that renders to multiple display devices. With this option, you run a single instance of your Unreal Engine application on your computer, but you set it up to render multiple separate rectangles of the scene's 3D space into different areas within a large window. You then use a technology such as NVIDIA Mosaic or NVIDIA Surround to split up that single large window and render each separate area on a different display devices. In this scenario, the benefit of using nDisplay in conjunction with Mosaic or Surround is that you can render viewports that accurately match the physical arrangements of your different monitors, even when those monitors do not lie along the same plane. However, all viewports are being rendered by the same instance of Unreal Engine, so you can't benefit from having multiple graphics cards installed on the same computer.

nDisplay Components

nDisplay adds several components to the usual Unreal system architecture:

A Plugin that works inside the Unreal Engine. It communicates and synchronizes information between all the application instances that make up the cluster, makes sure all instances render the same frame at the same time, makes sure each display device renders the correct frustum of the game world, and more.
A network provisioning and management application, called nDisplayLauncher . You run this application on a single computer in your network to automatically launch and quit your packaged Unreal Engine application on all the computers in your network.
A separate listener application, called nDisplayListener , that runs on each computer. This application listens for incoming requests from the nDisplayLauncher, and processes those requests on the local computer.
A shared configuration file that contains all the settings nDisplay needs to start up the right number of instances on the right computers, each rendering the right points of view on the game's 3D world to produce the illusion of a seamless rendering across all display screens or projectors. See the nDisplay Configuration File Reference .

Runtime Camera Control

Internally, nDisplay maintains a hierarchy of scene objects in virtual 3D space that you set up in the configuration file. For example, this scene hierarchy typically defines the position of a camera , and the positions of a set of screens —rectangles of 3D space that represent the real-world display screens or projection surfaces in the virtual world. The positions of these nDisplay scene objects are defined relative to a single root position that is always located at the origin (0,0,0) in virtual space.

When you run a Project with nDisplay enabled, the root of this virtual space is based on the position and rotation of a DisplayClusterRoot Component that is attached to a camera in your Level. Every frame, nDisplay uses the position and rotation of this root component as the starting point for the hierarchy of scene nodes that you set up in your configuration file.

By default, nDisplay creates a DisplayClusterRoot Component at startup and attach it to the default camera. The effect is that all devices and projectors in the whole nDisplay cluster automatically render the scene from the point of view of the active camera.

Blueprint API

You can control the behavior of the nDisplay system in your game's runtime logic using its Blueprint APIs.

To get to the functions exposed in these APIs:

For most nDisplay Blueprint functions related to cluster management, querying input devices, nDisplay rendering, and more, create a new N Display > DisplayCluster Module API node in your Blueprint.
Drag from the Out API pin of your node, and look under the Display Cluster category:

Click for full image.

Extending nDisplay

nDisplay offers many features out of the box for controlling real-time, synchronized rendering across multiple computers and output devices. However, there are a wide variety of projection systems and display surfaces, and you may need to extend the nDisplay rendering system to support your own choice of technologies. If you are comfortable programming in C++, and you understand how nDisplay works in typical use cases, you can extend nDisplay to support additional display and calibration technologies by building on top of its extendable rendering API.

The nDisplay API breaks the rendering pipeline into a few major concepts:

The DisplayClusterRenderingDevice , which is essentially an extension of the native IStereoRendering Interface.
The DisplayClusterPostProcess is a group of six callbacks that you can use to apply post-processing to specific viewports.
The DisplayClusterProjectionPolicy is responsible for custom projection methods, such as supporting Scalable Display or MPCDI to render to curved surfaces, or doing a simple planar projection.
The DisplayClusterRenderSyncPolicy is used for a variety of synchronization methods, like nvSwapLock , vSync or custom skip-frame sync for 24hz displays.

By creating your own specializations of the elements described above, you can customize the images produced by the nDisplay system to suit whatever projection or display technologies you work with, while still getting all the key benefits of the nDisplay clustering system, all without needing to modify the shipped Unreal Engine source code.

For a working model of how to set up implementations of these elements, see the source code for the PicpProjection and PicpMPCDI modules. You'll find these modules in the Unreal Engine source code, under Engine/Plugins/Runtime/nDisplay/Source .