Create a multi-window application

Prerequisites

• Set up the Unity Editor to build for Embedded Linux or QNX. For more information, refer to the documentation on Get started with Embedded Linux and Get started with QNX.
• Access to the target hardware where you can run the application to verify the multi-window behavior. For more information, refer to the documentation on Configurations for embedded platforms.

1. Configure the scene and camera components

1. In your Unity project, create a build profile for the target platform.
2. Create a scene for the build profile.
3. Add a second camera to the scene (menu:

   GameObject

   ?

   >

   Camera

   ?

   ).
   Note

   Unity includes a main camera by default. For a two window application, you need two cameras.
4. Select the second camera.
5. In the

   Inspector

   ?

   window, open the Output section, and set the Target Display to Display 2.

Display UI only on the second window (Optional)

1. Create a canvas (menu: GameObject > UI (Canvas) > Canvas).
2. Select the canvas.
3. In the Inspector window, set the Render Mode to Screen Space - Overlay and Target Display to Display 2.

2. Create the second window using C# script

1. In the Project window, create a C# script (context menu: Create > MonoBehaviour Script).
2. Replace the default script with the following:

   using System.Collections.Generic;using UnityEngine;using UnityEngine.Windowing;public class CreateWindowExample : MonoBehaviour{    List<DisplayInfo> displayInfos = new List<DisplayInfo>();    void Start()    {        DisplayInfo.GetLayout(displayInfos);            var settings = new GameWindowCreationSettings(            title: "Second Window",            width: 600,             height: 400,            position: new Vector2Int(0, 0),            cameraDisplayIndex: 1,         // Target Display index of the camera            displayInfo: displayInfos[0]  // Physical display that will contain the window        );            var op = GameWindowManager.Create(settings);            op.completed += (AsyncOperation o) => {            // Triggers when the window creation is complete            Debug.Log($"Window Created: {op.window.GetTitle()}");        };    }}

3. Configure the following key parameters as required.

   • displayInfo

     : Specifies which physical display contains the window. Retrieve the display information using

     DisplayInfo.GetLayout

     (recommended) or

     Screen.GetDisplayLayout

     . In the example,

     displayInfos[0]

     uses the first physical display.

   • cameraDisplayIndex:

     Specifies which camera's content to display based on the camera's Target Display setting from Step 1. For example, use

     0

     for Display 1, and

     1

     for Display 2.
4. Attach the script to a GameObject in the scene.

• Call

  GameWindowManager.Create

  and wait for the operation to complete before using the new window. Do not access the new window until the operation is complete as this results in a null reference error.
• To monitor the changes in the window state, use the

  GameWindow

  class methods such as PositionChangedThisFrame or ResolutionChangedThisFrame.

3. Build and run the application on target hardware

1. Build the Player for the Embedded Linux or QNX build profile.
2. Deploy and run the Player on the target hardware to verify whether the additional window appears on the correct display.

Limitations

• Unity supports a maximum of eight target displays, which limits the number of windows you can create.
• In fullscreen mode, secondary windows use the resolution of the physical display they appear on. Changing the window resolution through the

  GameWindow.SetResolution

  method isn't supported.
• GetLogicalDpi is currently not supported on Embedded Linux or QNX platforms. The method returns a default value of

  0

  on these platforms.

Additional resources

• GameWindowCreationSettings API reference

• CreateWindowAsyncOperation API reference

• Develop for Embedded Linux
• Develop for QNX