Pico 4 Ultra Development Guide

The LCC development workflow for Pico 4 Ultra is essentially the same as PICO's official VR project creation workflow; see the PICO Unity Integration SDK documentation. This guide builds on that to explain how to integrate the LCC Unity SDK for rendering 3DGS scenes.

Version Requirements

The software and package versions used in this guide are listed below. It is recommended to develop with the same versions; other untested versions may have compatibility issues:

See Development Environment Requirements for more detailed hardware and software requirements.

Note:

1. Because the PICO Unity Integration SDK has serious performance issues on the URP pipeline, the Built-in render pipeline is recommended; see its known issues.
2. If you test with Unity v6000.0.69f1 and find the app freezes or crashes, switch to Unity v2022.3 LTS: PICO 4 series devices have compatibility issues with apps that use Unity 6 and Vulkan together; see its known issues.
3. The Unity version, PICO SDK version and LCC SDK version all affect rendering and performance; try to keep each software version consistent with this guide.

Development Workflow

Step 1: Create the project

In the project template, select the 3D (Built-in Render Pipeline) type. Because the PICO Unity Integration SDK has serious performance issues on the URP pipeline, do not select the URP pipeline, as shown below:

Create a 3D (Built-in Render Pipeline) project

Step 2: Switch the platform

In the Unity menu, select File → Build Profiles to open the build window and switch the platform to Android, as shown below:

Switch the platform to Android in Build Profiles

Step 3: Import the PICO Unity Integration SDK

Download the PICO Unity Integration SDK from the PICO official website and install it following the PICO tutorial; you can also import it directly from GitHub at https://github.com/Pico-Developer/PICO-Unity-Integration-SDK.git. This guide uses version v3.4.0, as shown below:

Import PICO Unity Integration SDK v3.4.0

Step 4: Import the LCC Unity SDK

Open the UPM window via the Unity menu Window → Package Manager, click ＋ on the left, select Install package from disk from the dropdown, navigate to the LCC Unity SDK, and select the package.json file to import, as shown below:

Import the LCC Unity SDK via Install package from disk

Step 5: Configure the Unity environment

Configure XR Plug-in Management

In the Unity menu bar, select File → Project Settings, select XR Plug-in Management on the left, and check Initialize XR on Startup under the Android platform tab, as shown below:

Check Initialize XR on Startup in XR Plug-in Management

Select the PICO item under XR Plug-in Management and set the Android platform's Render Mode to MultiView, as shown below:

Set PICO Render Mode to MultiView

Select the Project Validation item under XR Plug-in Management and click Fix All to complete the necessary settings (this can also be skipped and created manually later), as shown below:

Click Fix All in Project Validation

Note:

• Clicking Fix All creates the necessary GameObjects in the currently open scene, so you need to delete the Main Camera and Directional Light in the scene.
• This example only fixes UIOrientation.LandscapeLeft; everything else is created manually.

Configure the Keystore

PICO development requires a Keystore. Go to Player → Android tab → Publishing Settings → Keystore Manager, create a new Keystore and complete the settings, as shown below:

Create a new Keystore in Keystore Manager

Set the company name and product name

PICO development does not allow the default defaultCompany. In the Player tab, set the correct Company Name and Product Name, as shown below:

Set the Company Name and Product Name

Configure quality options

In Project Settings, select the Quality tab and set Anti Aliasing = Disabled, Resolution Scaling Fixed DPI Factor = 0.7, and VSync Count = Don't Sync, as shown below:

Disable anti-aliasing and set DPI Factor and VSync in the Quality tab

Fill in the AppID

In the Unity menu, select PICO → Platform → Platform Setting to open the settings panel, and enter the AppID applied for on the PICO developer platform in Paste your App ID here; see Create a developer account, organization and app.

Enter the AppID in PICO Platform Setting

Configure Graphics

In Project Settings, select the Graphics tab, select the Android platform, and configure as shown below:

Configure the Android platform in the Graphics tab

Configure Player

In Project Settings, select the Player tab, select the Android platform, set Color Space = Gamma, uncheck Auto Graphics API and keep only Vulkan, with the other settings as shown below:

Set Color Space to Gamma and keep only Vulkan for the graphics API

Scroll down in the current tab and set Minimum API Level = Android 10.0, Scripting Backend = IL2CPP, API Compatibility Level = .NET Standard 2.1, and Target Architectures = ARM64, with the other settings as shown below:

Set Minimum API Level, Scripting Backend, API Compatibility Level and Target Architectures

Continue scrolling down in the current tab and set Active Input Handling = Input System Package (New), with the other settings as shown below:

Set Active Input Handling to Input System Package (New)

Step 6: Create the scene

Create a brand-new scene in Unity and delete the Main Camera and Directional Light. Right-click in an empty area of the Hierarchy window, and select XR → XR Origin (VR) from the popup menu to create the necessary XR objects.

Select the XR Origin (VR) object and add the PXR_Manager component via Add Component in the Inspector window, and configure its related properties as shown below:

Add and configure the PXR_Manager component on XR Origin (VR)

Select the XR Origin (VR) object, and in the XR Origin component of the Inspector window, set Tracking Origin Mode to Floor, with the other properties as shown below:

Set the XR Origin component Tracking Origin Mode to Floor

Select the Main Camera (the second-level child of XR Origin (VR)) and set the related properties of the Camera component in the Inspector window, as shown below:

Set the Camera component properties of Main Camera under XR Origin (VR)

In the Hierarchy window, right-click Create Empty to create an empty object named LCCManager, normalize its Transform, and attach the LCCManager script via Add Component, as shown below:

Create the LCCManager empty object and attach the LCCManager script

In the Hierarchy window, right-click Create Empty to create another empty object named LCCRenderer, and set its Transform with Rotation.x = -90 and Scale.x = -1, as shown below:

Create the LCCRenderer empty object and set Rotation.x = -90, Scale.x = -1 to align the coordinate system

Rotation.x = -90 and Scale.x = -1 are the alignment transform from the LCC data coordinate system (Z-up right-handed) to the Unity coordinate system (Y-up left-handed); see "LCC Data Coordinate System" in Unity SDK Introduction.

Write a C# script named LCCRenderer.cs with the following code:

using LCCCore;
using UnityEngine;
using UnityEngine.XR;

public class LCCRenderer : MonoBehaviour
{
    public LCCManager m_manager;
    public string m_FilePath;

    private LCCCore.Renderer m_renderer;

    private void Awake()
    {
        XRSettings.eyeTextureResolutionScale = 0.8f; // Lower the texture resolution to improve performance
    }

    void Start()
    {
#if UNITY_EDITOR
        m_manager.SetPlatformType(PlatformType.PC);
        m_renderer = m_manager.GetRender(this.gameObject.transform);
        m_renderer.Load(m_FilePath, onProgress, onLoaded);
#else
        m_manager.SetPlatformType(PlatformType.Pico);
        m_renderer = m_manager.GetRender(this.gameObject.transform);
        m_renderer.Load($"{Application.persistentDataPath}/LccData/meta.lcc2", onProgress, onLoaded);
#endif
    }

    private void onProgress(float v)
    {
        Debug.Log("progress:" + v);
    }

    private void onLoaded()
    {
        m_manager.SetStartLod(2);
        m_renderer.SetEnvironment(false);
        Debug.Log("Data loaded");
    }
}

Attach this script to the LCCRenderer GameObject in the Hierarchy window, then drag the LCCManager GameObject onto the script's Manager property in the Inspector window, and finally fill in the path of the LCC file.

Attach the LCCRenderer script and bind Manager and the file path

To facilitate debugging in the Unity Editor and packaging directly to an Android device, the code uses compilation macros to distinguish the runtime environment: in the Editor it uses the path specified by m_FilePath; on the Android device it uses the on-device data source. The on-device data is placed as follows:

1. First run the packaged app once on the PICO device.
2. After the app is installed, go to its data directory (generally PICO device storage → Android → data → app BundleID → Files; refer to the Android app installation path for the specific directory), and create an LccData folder under the Files subdirectory.
3. Copy all the LCC data source into the LccData folder.

Note:

1. In practice, it is recommended to place the PICO app's data source on a server rather than packaging it directly into the app.
2. The Pico 4 Ultra device renders about 700,000 Gaussian primitives on screen at once, roughly two orders of magnitude less than the ~25 million on PC. It is mainly recommended for small-scene, single-object rendering and display; large scenes are smoother over PC streaming.
3. When rendering large LCC scenes, it is recommended to set StartLOD to 2 and disable the environment data display (as in the example code).

Related References

• For project setup and performance optimization, see Project Settings Optimization Guide and Render Performance Parameter Settings Guide.
• For other PICO development workflows, see the official documentation: PICO Developer Documentation.