Multi-Camera Rendering Development Guide

The LCC Unity SDK supports rendering with multiple cameras simultaneously in single-scene full rendering mode. The following uses an example of one main camera plus two secondary cameras to describe the complete steps for implementing multi-camera rendering.

Step 1: Create the scene and GameObjects

Create a brand-new scene in Unity. Unity creates Main Camera and Directional Light by default.

Set up Main Camera

Select Main Camera in the Hierarchy window, and set its properties in the Inspector window as shown below.

Set the Main Camera properties

Create LCCManager

Right-click an empty area in the Hierarchy window, select Create Empty from the pop-up menu to create an empty GameObject, name it LCCManager, normalize its Transform, and add the LCCManager script to it via Add Component.

Create the LCCManager GameObject and add the LCCManager script

Create LCCRenderer

Right-click an empty area in the Hierarchy window, select Create Empty to create an empty GameObject, name it LCCRenderer, and set its Transform to Rotation.x = -90 and Scale.x = -1.

Create LCCRenderer and set its Transform (Rotation.x = -90, Scale.x = -1)

Note:

The Transform settings of the LCCRenderer GameObject (Rotation.x = -90, Scale.x = -1) align it with the LCC data coordinate system. For details on coordinate system alignment, see "LCC Data Coordinate System" in Unity SDK Introduction.

Create secondary rendering cameras

Right-click an empty area in the Hierarchy window to create two additional rendering cameras, name them Camera01 and Camera02 respectively, and set the properties of these two cameras as shown below.

Set the Camera01 properties

Set the Camera02 properties

In this example, the two cameras' Viewport Rect is configured to place them in the lower-left corner and lower-right corner of the main rendering window respectively.

Step 2: Write the multi-camera script

Create a new C# script named MultiCamera.cs with the following code:

using LCCCore;
using UnityEngine;

public class MultiCamera : MonoBehaviour
{
    public LCCManager m_manager;
    public string m_FilePath01;
    public Camera m_camera01;
    public Camera m_camera02;

    public Transform m_transform01;
    private LCCCore.Renderer m_renderer01;

    private int m_currentFileIndex = 0;

    void Start()
    {
        m_manager.SetPlatformType(PlatformType.PC);
        m_manager.SwitchRenderPass(ActiveRenderMode.SingleRender);

        Debug.Log("Started ");
        m_renderer01 = m_manager.GetRender(m_transform01);

        m_currentFileIndex = 0;
        m_renderer01.Load(m_FilePath01, onProgress, onComplete);
    }

    private void onProgress(float _progress)
    {
        Debug.Log($"[LCCRenderer] file {m_currentFileIndex} load progress: {_progress:P1}");
    }

    private void onComplete()
    {
        Debug.Log($"[LCCRenderer] file {m_currentFileIndex} loaded");

        m_manager.AddCamera(m_camera01);
        m_manager.AddCamera(m_camera02);
    }

    private void OnDestroy()
    {
        m_manager.RemoveCamera(m_camera01);
        m_manager.RemoveCamera(m_camera02);
    }
}

Note:

• Secondary cameras must be registered after the LCC scene finishes loading, so AddCamera is called in the onComplete callback.
• The script file name must match the class name (MultiCamera.cs corresponds to class MultiCamera), otherwise it cannot be attached to a GameObject.
• The main camera is set via SetMainCamera, and secondary cameras are added via AddCamera; you cannot add the main camera as a secondary camera.

Step 3: Attach the script and set properties

1. Attach the MultiCamera.cs script to the LCCRenderer GameObject in the Hierarchy window.
2. In the Inspector window, drag the LCCManager GameObject onto the script's Manager property.
3. Drag the Camera01 and Camera02 GameObjects onto the script's Camera01 and Camera02 properties respectively.
4. Fill in the LCC file path in the script's File Path01 property.

Attach the MultiCamera script and set its properties in the Inspector

Step 4: Run

Click the Play button in the Game window to see the real-time rendering effect of multiple rendering cameras in the scene.

Multiple rendering cameras rendering simultaneously after running

Key Steps

The key steps for implementing multi-camera rendering:

1. Make sure the scene is in single-scene full rendering mode (SwitchRenderPass(ActiveRenderMode.SingleRender) and the data goes through the Full Load path).
2. The main camera is set via SetMainCamera; secondary cameras are registered via AddCamera after the scene finishes loading (in the onComplete callback).
3. Control each camera's rendering area on the screen through its Viewport Rect.
4. When the object is destroyed (OnDestroy), remove secondary cameras via RemoveCamera to avoid dangling references.

Multi-Camera Rendering Notes

• Only full rendering mode is supported. The LCC SDK currently only supports multi-camera rendering in full rendering mode under a single scene. For performance optimization, in chunked rendering mode the SDK only loads and renders the visible data inside the camera frustum; and to pursue high performance, the CPU-side scene node data filtering, data assembly, and data upload from CPU to GPU are all asynchronous, so it cannot process and render data for multiple cameras separately within the same frame.

• Make sure the scene is in full rendering state. To use the complete multi-camera rendering feature, configure the scene to full rendering (Full Load) mode: use ActiveRenderMode.SingleRender and enable full rendering on the Renderer (Renderer.SetRenderAll(true), which takes effect on the next Load()). For details on rendering modes and performance parameters, see PC Quick Start Guide.

• The more cameras, the higher the performance cost. Each additional rendering camera adds one complete rendering pass, so performance degrades accordingly. Multi-camera rendering is recommended on high-performance computer devices.

• Only supported on PC/Mac. AddCamera / RemoveCamera are only effective on PC/Mac platforms.

Multi-camera APIs

The LCC Unity SDK provides the following camera-related APIs through LCCManager. Secondary cameras must be registered via AddCamera after the LCC scene finishes loading (that is, in the onComplete callback).

SetMainCamera

// Return value: void
public void SetMainCamera(Camera _cam)

Sets the main rendering camera. LCC uses this camera for frustum culling, LOD selection, sorting, and other operations.

Usage example:

m_manager.SetMainCamera(Camera.main);

Notes:

• Must be set before Renderer.Load().
• Call it again when switching cameras.
• Only supported on PC/Mac.
• Pass null to clear the main camera.

AddCamera

// Return value: void
public void AddCamera(Camera _cam)

Adds a secondary camera. Secondary cameras participate in rendering but do not affect LOD selection.

Usage example:

m_manager.AddCamera(m_camera01);

Notes:

• Only supported on PC/Mac.
• You cannot add the main camera as a secondary camera.
• LOD selection is determined only by the main camera; secondary cameras reuse the data filtered by the main camera for rendering.

RemoveCamera

// Return value: void
public void RemoveCamera(Camera _cam)

Removes a previously added secondary camera.

Usage example:

m_manager.RemoveCamera(m_camera01);

Notes:

• Only supported on PC/Mac.
• It is recommended to call it when the object is destroyed (OnDestroy) to clean up the secondary camera reference.