The LIV SDK adds support to your game for Mixed Reality Capture and Virtual Cameras.

The LIV SDK is intended for developers to add support to their games. If you are a content creator or someone that wants to use LIV to record content with the supported games, you do not need to install the LIV SDK.

The LIV SDK provides a spectator view of your application. It contextualizes what the user feels & experiences by capturing their body directly inside your world! Thanks to our software, creators can film inside your app and have full control over the camera.

With the power of out-of-engine compositing, a creator can express themselves freely without limits; as a real person or an avatar!

How It Works

The LIV SDK spawns a camera inside your game which is controlled by LIV. This camera then renders your app into a background and foreground, to allow the user’s body to be composited in. The background & foreground are separated by clipping geometry, based on the user’s location within the scene. These textures are then submitted for composition.

The compositor takes in multiple timestamped sources, performs latency compensation, and composites them together. This output can then be recorded or streamed using software like OBS or Discord.

Doing this work out-of-engine comes with some significant benefits:

• Optimised resource use - we only do the bare minimum work required in the SDK, allowing it to stay lightweight and easy to maintain.
• Accurate latency compensation works without any additional effort from you, the developer.
• Additional camera types, effects, and layers can be added in future updates to the LIV App, making your SDK integration last longer.

For this to work well, we have developed a minimum-latency, high-performance transport layer that also handles resource management. LIV’s footprint is almost entirely dependent on how well-optimised your application is!

The LIV App on Steam connects with games that have integrated the LIV SDK to do realtime composition.

The LIV App on Steam is used to capture and composite games that have added the LIV SDK.

You can download the LIV App on Steam for free!

When running VR applications on a PC, LIV works with these runtimes:

• SteamVR (OpenVR API)
• OpenXR (When provided by SteamVR)

A SteamVR compatible headsets are supported. Games published on Steam or Viveport with the LIV SDK installed will be automatically detected by LIV.

LIV works with a PC at this time. Standalone devices not connected to a PC do not work.

At a high level, there’s 4 steps to releasing your game with LIV support:

1. Get the latest LIV SDK
2. Add the LIV SDK to your app
3. Test the integration
4. Release your app with LIV

The LIV SDKs can be downloaded through our Developer Portal. The process is the same whether you need the Unity or Unreal SDK.

1. Register at dev.liv.tv with your work email

2. Create your account, using your business contact

3. Create your game record with LIV

4. Select your game and navigate to Downloads

5. Agree to the Terms of Service & Privacy Policy

6. Generate your app specific SDK by selecting Prepare. Note, if you create a new game you’ll need a new SDK. Select Prepare

7. Download the SDK and you’re ready to move onto installation

1. Backup your project.

2. Import the LIV SDK into your project. (Assets > Import > Custom Package)

3. If Unity prompts you to upgrade deprecated APIs, then say "Yes".

   

4. Add the LIV component anywhere in your project. Either spawn it every scene or use DontDestroyOnLoad.

5. Assign HMD Camera and Stage properties in the LIV script.

   

6. If using Universal Render Pipeline, set upgrade package to support URP.

   Click here for the URP Walkthrough

7. Test your integration works, click here for more info.

Read on for more details and information on customising your integration.

The LIV Unity SDK is interested in only two GameObjects, your HMD camera & "Stage".

The "Stage" object is where LIV's camera will be inserted in your hierarchy. It must be set to the GameObject that contains the player's hands. It must contain the entire player.

HMD Camera

This is the camera responsible for rendering the user’s HMD.

The LIV SDK, by default clones this object to match your application’s rendering setup. You can use your own camera prefab should you want to!

Stage

This is the topmost transform of your VR rig.

When implementing VR locomotion (teleporting, joystick, etc), this is the GameObject that you should move around your scene. It represents the centre of the user’s playspace.

StageTransform

This transform is an additional wrapper to the user’s playspace, meant to allow for user-controlled transformations for special camera effects & transitions. This is optional.

If a creator is using a static camera, this transformation can give the illusion of camera movement. This video, for example, is filmed without any extra cameraman!

Game-Driven Camera for Avatars

Call liv.render.SetPose(position, rotation, vfov) every frame to control LIV's camera when avatars are being used!

Simply stop calling it to return control to the user's own camera.

Exclude MonoBehaviours

This is for removing unwanted scripts from the cloned MR camera when not using a camera prefab.

By default, we remove the AudioListener, Colliders and SteamVR scripts, as these are not necessary for rendering MR!

The excluded string must match the name of the MonoBehaviour.

Provide Your Own Camera Prefab

By default, LIV uses the HMD camera as a reference for the Mixed Reality camera.

It is cloned and set up as a Mixed Reality camera. This approach works for most apps.

However, some apps can experience issues because of custom MonoBehaviours attached to this camera.

You can use a custom camera prefab for those cases.

Spectator & Passthrough Layer Mask

The layer mask properties on the LIV component define which layers will be visible to the LIV camera.

By default, the spectator mask is used for the LIV camera. When passthrough mode is enabled on a device, the passthrough mask will be used instead of the spectator mask.

Hiding Avatars/Hands

You should use these masks to hide in-game avatars from the LIV camera, leaving a space for LIV to composite in the user's body or LIV avatar.

Below is a simplified example setup showing how the two masks work with a VR project.

Additional Uses

• Rendering special affects/UI for the LIV camera only. For example a score or healthbar.
• Hiding HMD-based effects/particles.

Shader Variants

LIV SDK adds MR-specific shader variants. That means that you can write a specific portion of existing shader to be used only for the mixed reality feed.

• LIV_MR: Render into background and foreground texture
• LIV_MR_BACKGROUND: Render only in the background texture
• LIV_MR_FOREGROUND: Render only in foreground texture

#if defined(LIV_MR_BACKGROUND)
  col = fixed4(1, 1, 0, 1);
#elif defined(LIV_MR_FOREGROUND)
  col = fixed4(0, 1, 1, 1);
#else
  col = fixed4(0, 0, 1, 1);
#endif

Rendering Events

See the API reference for a list of Actions on the LIV component that can be used for adding custom behaviour to the LIV SDK.

Fix Post-Effects Alpha Channel

If your game is using any post-effects it is possible that the foreground texture alpha channel is corrupted.

By turning on this feature LIV tries to fix this issue by capturing the alpha channel before any post effects are applied and then simply overwriting the final alpha channel output with the captured one.

For Post-Effect Stack v2

• On the Post-Process Layer, enable the Keep Alpha option.

Disable Standard Assets

This is a property on the LIV component.

Unity’s standard assets can interfere with the alpha channel that LIV needs to composite MR correctly.

This option disables all standard Unity assets for the Mixed Reality rendering.

Setup

Make sure you've already setup the Unity SDK before following these steps:

1. Navigate to LIVSDKSettings (Usually located at Assets/LIV/Resources/LIVSDKSettings) and click the "Switch To Universal Render Pipeline" button.

   

2. Find File/Build Settings/Player Settings/Other Settings/Scripting Define Symbols and add LIV_UNIVERSAL_RENDER

   

Versions Below 2.0

Additionally, for Versions 1.5.1, 1.5.2, 1.5.3 follow the following steps:

1. Find your Forward Renderer Asset(s) in the Unity project. (Note: There can be multiple renderer assets in your project. Make sure you're doing this for all of the renderer assets that will be used with LIV)
2. Under Renderer Features, add "SDK Universal Render Feature".
3. On your LIV component enable “Fix Post-Effects alpha channel”.

High Definition Render Pipeline

Currently unsupported.

Intro

Meta Presence Platform features for Mixed Reality are supported on the Unity LIV SDK from version 2.0+.

Please note that this functionality is currently in beta, and development around issues and features will updated regularly, for more info on specific updates check the changelogs.

Constraints and Limitations

• Realtime composition is not yet supported. Post-production work will need to be done for background removal of the live camera subject

• The app must be run on PCVR with the Presence Platform features working

• Presence Platform requires Oculus set as the active OpenXR Runtime

• LIV App uses overlays so SteamVR must be running

• Tracked cameras only works with SteamVR

• When using both SteamVR and Oculus at the same time, the spaces need to be synced via OpenVR Space Calibrator

• Quest Scene data must be set prior to connecting to SteamVR. If changes to the Scene are made, you must reconnect to SteamVR

• DirectX11 is currently supported. DirectX12 and Vulkan are not supported at this time.

Video Tutorial

Watch our tutorial for a step-by-step walkthrough for integrating the Meta Presence Platform.

Sample Project

A sample project is available on GitHub with the supported Presence Platform capabilities if you’d like to follow along.

The Meta XR All-in-One SDK (UPM) v65.0 and later is compatible with LIV’s Presence Platform. Earlier Meta SDKs may work but if any issue is encountered, please try upgrading the Meta SDK or reach out to us at support@liv.tv.

Meta Present Platform Passthrough

Passthrough enables a player to see their real world environment while wearing the Quest headset. From a 3rd person capture perspective, the camera will see the player in their real world environment as well as the in-app experience.

Setup

1. First set up the LIV SDK in your project, if you haven't already.

   Click here for our quickstart guide.

   These next steps are specific to Meta Presence Platform integration.

2. Hide objects that you don’t want to show in Mixed Reality mode.

   In the Mixed Reality mode, you may not want certain objects to be rendered (such as sky boxes, skydomes, background meshes etc) and instead have your real world live environment, such as your actual living room, show through.

   In the Layer management UI, create a layer for these objects you want to hide. Now tag the individual objects to it. You can also do this in script if you want.

   

   In the LIV component in the scene you can uncheck the Passthrough layer, so objects tagged with that layer are now hidden from the LIV render passes.

   The callbacks onPassthroughActivated and onPassthroughDeactived are also available for further customisation when Passthrough mode is toggled via the LIV App.

3. Update tracking ID: Obtain tracking ID using developer portal

   

   Add your tracking ID to the tracking ID field in LIVSDKSettings

   

   In case of updating LIV SDK locate tracking ID in your version control under file SDKStructs.cs/public const string SDK_ID = "YOUR_TRACKING_IDENTIFIER";

That's it! You should now have Meta Presence Platform passthrough enabled for for your project.

Overview

At a high level, the process is as below;

1. Setup your Space in the Quest OS
2. Start Meta Quest Link. Doesn’t work with Virtual Desktop or Steam Link.
3. Ensure Meta Quest Link is set as the active OpenXR runtime.
4. In the Beta tab, ensure Developer Runtime Features,Pass through over Meta Quest Link, and Spatial Data over Meta Quest Link is enabled.
5. Start LIV app on Steam.
6. Start game with LIV 2.0 SDK
7. Start LIV Mixed Reality Capture and manually select the game
8. Start SteamVR
9. Capture

We have a comprehensive step-by-step guide to help you get set up for recording on our helpdesk - click here to view.

Setting up Quest For Presence Platform

1. Ensure Meta Quest Link is set as the active OpenXR runtime.

   

2. In the Beta tab, ensure Developer Runtime Features,Pass through over Meta Quest Link, and Spatial Data over Meta Quest Link is enabled.

   

Unity crashes during frame debugging

When LIV is attached to Unity editor and it's in play mode, using frame debugging, exiting play mode suddenly, the next time you connect the LIV SDK to Unity, it will crash. This can be avoided by disabling frame debugging after being done with debugging and unpausing the player to let LIV SDK recover before exiting play mode.

Game isn’t showing up in the LIV App Auto detected games list

LIV app expects your game root folder to have the game files, rather than a folder within a folder. Ie: steamapps\common\[game] rather than steamapps]common\[game]\[game]

The LIV avatar's head doesn't move when my game is running

This likely means that your application is running using Oculus, or OpenXR through Oculus. Please make sure you're either using OpenXR through SteamVR, or SteamVR as your runtime.

How do I control the LIV camera?

You can fully control the camera by calling:

liv.render.SetPose(position, rotation, vertical field of view)

The camera is automatically released whenever you stop calling this function.

Note that only LIV avatar cameras are currently controllable, as MR cameras must remain aligned with their physical sensors 😉

I can't see the avatar / player in the LIV output

If your game is using post-processing it is possible that the foreground texture alpha channel is corrupted.

You can fix it by enabling the "Fix Post-Effects alpha channel" toggle on the LIV component. If you're using the Universal Render Pipeline, make sure to follow our steps to have it correctly work.

LIV doesn't activate when I capture a build of my game

Make sure your Unity project is targeting 64bit builds. LIV is only compatible with 64bit applications.

LIV.cs

This is the main LIV component.

Properties:

SDKRender.cs

Owner of rendering for the LIV SDK.

Constructors:

Properties:

Public Methods:

[2.1.0] - 2024–09-30

Added

• Updated UI and visual design for LIV component editor.
• UI toggle enabling override of output alpha with depth buffer.
• Feature flag to observe enabled/disabled status of LIV avatar.
• Changelog file to project.
• Improved error handling for incorrect build targets.
• Improved handling of service initialization errors.
• Default LIV settings asset.

Fixed

• Spam warnings generated from calling a LIV function from OnValidate.
• Internal bugs.
• Issue with generation of LIV settings object.
• Bugs in SDK renderer.

[2.0.2] - 2024-06-18

Fixed

• Internal bugs.

[2.0.1] - 2024-06-18

Fixed

• Internal bugs.

[2.0.0] - 2024-11-2024

Added

• Support for Meta Presence Platform Passthrough, Scene Anchors, Hand Tracking

[1.5.3]

Changed

• LIV SDK bridge is excluded from non-windows platforms.
• Moved all strings to editor only to prevent garbage collection.
• Fixed undefined bridge state handling.
• Universal render pipeline reporting.
• Improved code readability and internal behavior.

[1.5.2]

Added

• canSetPose for detecting if the game can change the pose during runtime.. It can be accessed from liv.render.canSetPose.

[1.5.1]

Added

• Added universal render pipeline support

Changed

• Changed approach to extracting alpha information for the foreground layer of LIV; should fix foreground compositing behaviour for most titles, including those on deferred rendering pipelines.
• Near and far frustum parameters for LIV’s camera are now driven by the game’s HMD camera, and can be manually controlled using LIV.render.cameraInstance.farClipPlane & nearClipPlane
• Modified SetPose to be world space by default.

If you’ve used the 1.5 SDK and want to upgrade to 2.0 without using any of the new Presence Platform supported features, it’s straight forward.

1. Backup your project.

2. Import the LIV 2.0 SDK. If Unity asks for consent for updating the scripts, it’s safe to say Yes.

3. The serialized properties for the HDM camera and Stage transforms in the LIV component should pick up their old values but it’s good to do a sanity check afterwards.

Unreal support for Meta Presence Platform is coming later in 2024. Follow our Discord or join our newsletter for updates

1. Download the LIV SDK as outlined in Getting the LIV SDK

2. Extract and copy the LIV plugin folder (contains LIV.uplugin) into the Plugins directory of your project. Create the directory if it doesn't already exist.

3. If your project does not already support C++, add it by selecting "Tools" > "New C++ Class".

4. Regenerate the Visual Studio solution for your project. To do so, right-click your .uproject file, then select "Generate Visual Studio project files".

5. Open the Visual Studio solution (.sln) and ensure LIV is loaded in the solution explorer.

6. Run the Unreal Editor for your project within Visual Studio by selecting Build and run your project to launch the editor. You can just press F5 or click the button in the screenshot below.

7. Ensure the LIV plugin is loaded in the Plugins window ("Edit" > "Plugins")

NOTE: Currently LIV only supports DirectX11 and not DirectX12. If you are using DirectX12 you will be prompted to switch to DirectX11.

Quick Integration

Just by installing the plugin your game is able to be captured by LIV, for more advanced customisation see "Advanced Integration".

Advanced Integration

The LIV plugin provides a variety of rendering methods for capturing your gameplay. To change the method used you can select a different class for "Capture Method" in the LIV Plugin Settings. You can access this from Edit > Project Settings, in the LIV section under the Plugins header.

The fastest (and default) capture method is ULivCaptureSingle, although translucent objects will not render in the foreground.

If you want translucent objects to render on top of the player or avatar, then you must use ULivCaptureGlobalClipPlane(No)PostProcess.

Global Clip Plane

ULivCaptureGlobalClipPlane(No)PostProcess capture methods require the global clip plane to be manually enabled. Warning: this will incur a performance penalty.

If you wish to enable the global clip plane anyway, you can do so in the Project Settings > "Support for global clip plane...":

Show and Hide Actors and Components

By getting a reference to the Liv Local Player Subsystem via a Player Controller you can show and hide actors and components. A typical place to put the calls would be within the Begin Play and End Play events of your pawn. Make sure to check the validity of the subsystem!

We are aware of a performance bug (UE-86191) affecting UE4.23 onwards, if this issue affects you or your customers we recommend voting on the issue.

Adding the following to your DefaultEngine.ini may help mitigate the performance issues:

[/Script/Engine.RendererSettings]
r.SceneRenderTargetResizeMethod=2
r.SceneRenderTargetResizeMethodForceOverride=True

1. If using a Meta headset, ensure the runtime in SteamVR is set to SteamVR, not OpenXR (How to set SteamVR as your OpenXR runtime)

2. Make sure the game is playable before running with LIV. This step establishes a baseline that any impacts to the game could potentially be due to LIV and the LIV SteamVR Driver.

3. Start LIV & make sure LIV Output is running

Select Mixed Reality Capture, Start PCVR Mixed Reality Capture. Starting the capture will launch 2 windows; the compositor LIV Output window & the LIV Settings window

Select Camera -> Add (green camera with + sign) -> In the Type drop down menu select Video camera -> In the device drop down menu select your camera device here -> In the Resolution drop down menu select the resolution your camera is set to Note: If you are using Nvidia Broadcast make sure to scroll down and use ARGB -> Save

Run OBS capturing the LIV Output using game capture and also capture SteamVR VR View using game capture. We do this to record the output as an audit/history of changes.

4. Start game, once with Auto and another with Manual

Sync & Launch via the Auto tab in LIV Select the game in the drop down menu and select Sync & Launch. LIV does its best to automatically detect supported launched games on Steam and populate the dropdown.

Try launching the game separately, and manually target the game.exe with LIV through the “Manual” tab

5. Verify if any in-game options are present as some games have added controls to enable LIV.

Any launch issues (special options required, desktop window issues) - Help Guide Check menu options for graphics quality and mixed reality specific settings

6. Mixed Reality Capture checks

Viewing the compositor window LIV Output with Default Compositing effect selected, check objects and any in game UI for correct foreground behavior. Correct behavior will show the person in front or behind game objects, depending on the angles. Using OVR Advanced Settings to change angles is helpful at this point.

Check again in LIV’s dump + composite mode Effect mode for proper behavior. Dump + Composite mode shows the individual layers that make up the composition.

Check various angles by rotating play space with OVR Advanced Settings using the Rotate Space slider in the Offsets tab

Check Fake Lighting modes in LIV.

Check that the FoV override features behaves accurately

Calibration check, ensuring the virtual and real controllers are aligned and the latency of controllers are minimal.

Check live re-calibrations Do a quick bad calibration and see if it takes, you will be able to quickly tell by checking calibration in the LIV Output window.

Measure performance impact with fpsVR log

Set up Quest, SteamVR, and LIV. The latest steps and information can be found on our help desk guide. This process will change as we make improvements. It’s also best to test with a static camera rather than a dynamic camera, just for the reason it’s not as involved to set up. The differences between the static camera and dynamic camera would be due to tracking inconsistencies with the LIV App rather than SDK integration.

If your are testing Passthrough:

1. In LIV, on the Capture -> Manual page ensure that Effect is Dump + Presence Platform
2. In LIV, on the Output that Hide Background is enabled

Top Left: Foreground RGB

Top Right: Alpha If “Hide background” is enabled

Foreground alpha (pink) & Background alpha (blue)

Bottom Left: Background RGB

Bottom Right: Composite

What to look for, in addition to all the criteria covered in Basic Mixed Reality testing.

• With Hide background enabled, all the elements in your game that you’ve specified to be hidden in Passthrough mode are black in the foreground, background, and Alpha quadrants.
• In the bottom right composite, you’ll see the real life camera feed with the foreground. The background will not be visible in the composite.
• If you’re testing with a default avatar camera, you should see the green LIV avatar being obstructed as different game objects go in front of the player. Vice versa, the default LIV avatar will block background objects.
• For real cameras, LIV does not have a live segmentation (background removal) at this time. It’s best to use a green screen and go through calibration.

When verifying other Presence Platform capabilities like hand tracking, scene and anchors it is not necessary to use Dump + Presence Platform and enabling Hide background.

• You may use the dump + composite
• With hand tracking, you should verify that the virtual hands and avatar hands are lined up and the composite reflects in-headset movements
• With scene and anchors, you should be seeing the composite respecting the anchors and scene you’ve set up with your game play

• Switch to Avatar Capture mode Help Guide
• Check controller/tracker behavior, making sure controllers/trackers (if using) are behaving properly. We want to see the avatar in LIV reflect the real life movements.
• Check the in-headset UI, making sure you are able to use the LIV avatar menu in headset Help Guide
• Check if an in-game avatar - if present. If in game avatar is present check for settings to disable it in the game settings menu
• If you’ve implemented a game driven LIV camera (eg. Eye of the Temple, Vail, Blaston), enable ‘Use Game Camera’ in the options Open the menu -> Select Avatar -> Game Settings menu will be on the left Disable the custom game camera for games that use a custom camera in avatar mode, uncheck "Use Game Camera" while in the avatar UI

• Measure performance impact with fpsVR log

Once you’ve finished integrating and testing, we can add your game to our officially supported games on liv.tv/games. Content creators are always looking for new games to record and make content with and listing your game here will help it get discovered.

1. Reach out to us at hi@liv.tv letting us know your game has been released with the LIV SDK. Please provide a thumbnail image, release dates, and links to your store pages on Quest or Steam.
2. We’ll review the game and verify everything works before adding it to the list. We’ll confirm with you once the game has been added.
3. If you’re interested, you can also coordinate marketing with LIV to promote integration and reach our community of content creators.

Long story short, they are URLs that are invokable as "shell commands" in Windows. As long as LIV is installed, and has been run once on a system, these commands will work when called from anywhere. Some commands will automatically start LIV, and boot LIV Capture. Some commands won't do anything if LIV is not already running and active.

You can call them manually, using the Windows "Run" prompt (Win+R). You may also create shortcuts to these commands using Windows Explorer: New -> Shortcut, then enter your command. You can then create a hotkey for that shortcut by modifying its properties.

Behind the scenes, LIV registers itself as a URI Scheme handler for the liv-app "protocol". When Windows is asked to execute a URI as a shell command, it will look for a registered handler, and then start that program. When LIV is already running, a second instance of LIV is loaded - it then sends the command to the first instance of LIV before closing itself. Naturally, this process takes some time. We don't recommend using this interface for high-frequency control of LIV.

These commands interact with LIV Capture for PCVR. These commands will not automatically launch LIV Capture if LIV is not already running.

liv-app://camera/set/<INDEX>

EG. liv-app://camera/set/2

Changes the currently active camera in LIV. The index is the number of the camera in the camera list, starting from 0. If you provide a camera index that is "out of bounds", the command will be ignored. You may re-order cameras in LIV by modifying the configuration file in %localappdata%\LIV\App - modify the CompositorBasic.CameraProfiles array.

liv-app://camera/set/fovOverride/<NUMBER>

EG. liv-app://camera/set/fovOverride/43.5

Sets the current camera's FoV override value. Set the FoV to 0 to clear the override. Has no effect on avatar cameras; see avatar camera plugins.

liv-app://camera/add/fovOverride/<NUMBER>

EG. liv-app://camera/add/fovOverride/-1.5

Adds to the current camera's FoV override value. If no override is set, it will use the camera's native FoV, then add to it as the override. Has no effect on avatar cameras; see avatar camera plugins.

liv-app://camera/toggle/freeze

If you are using LIV with a tracked camera (IE. You have a SteamVR tracker attached to a camera) and you are not moving it, you can temporarily freeze it in place. This command toggles the camera's frozen state.

All of the below commands will launch LIV if it is not running, then execute the command.

liv-app://launch/compositor

Starts PCVR Capture if not already running.

liv-app://launch/streamerkit

Starts LIV StreamerKit.

liv-app://focus/app

Brings LIV into the foreground.

liv-app://capture/manual/pid/<PROCESS ID>

EG. liv-app://capture/manual/pid/1337

Starts PCVR Capture if not already running, then switches to manual capture mode and attempts to capture the process ID given.

liv-app://launch/steam/<STEAM APPID>

EG. liv-app://launch/steam/1098100

Starts PCVR Capture if not already running, then switches to auto capture mode and launches the Steam game provided. Will not launch Steam games that are not detected by LIV. See the command line documentation for how to get a list of installed LIV games. Once the game is loaded, LIV will automatically begin capturing it.

liv-app://launch/viveport/<VIVEPORT GAME ID>

EG. liv-app://launch/viveport/8fd7deb0-64d8-48b1-bd44-87db84f37de8

Starts PCVR Capture if not already running, then switches to auto capture mode and launches the Viveport game provided. Will not launch Viveport games that are not detected by LIV. See the command line documentation for how to get a list of installed LIV games. Once the game is loaded, LIV will automatically begin capturing it.

Avatar camera plugins are currently managed through our community Discord, please join it and ask for access to the template project in the #camera-plugin-chat channel!

You will be able to publish plugins to the #camera-plugin-releases channel.

Avatar camera plugins are C# projects that compile a library that interfaces with LIV's Unity-based avatar renderer. You may control LIV's camera, or modify a user's avatar or scene.

LIV uses the registry to store a few helpful paths for locating and interacting with a LIV installation.

All registry keys are stored under the 64-bit Current User hive, in the location:

HKEY_CURRENT_USER\SOFTWARE\LIV.App

Stored here are the following keys:

They are updated whenever LIV is opened. You can use the BaseDirectory path along with LIV.App.CommandLine.exe for easy access to the command-line API!

ExternalApplications

If you've integrated the LIV SDK, but are not distributing through Steam, Meta Quest App Store, NetVios, or Viveport, you may add an entry to this sub-key and LIV will attempt to detect, launch, and automatically capture your app.

The format for these entries is described below, in JSON - this directly translates to the structure in the registry.

"ExternalApplications": {

  // An opaque string identifier for your application.
  "custom-app-id": {

    // User-visible name.
    "Name": "My Custom Application",

    // The app's install folder. Used to detect game engine & SDK version.
    "InstallPath": "C:\Path\To\App",

    "Executable": "C:\Path\To\App\Executable.exe",
    "Arguments": "-your -options -here",
    "WorkingDirectory": "C:\Path\To\App" // Optional.
  }
}

It is best practice, if you are adding your application to this list, to proactively update the values stored in the registry whenever your application is installed, run, or uninstalled.

If LIV cannot find the executable, or install path, it will not be added to LIV's capture list. Additionally, if LIV cannot find the LIV SDK in the install path, it will not be added.

Changes to the registry are not live. You need to restart LIV for any changes to apply.

You can find LIV's command line interface in the install folder, which you can navigate to by going through your Steam Library: Steam > Library > LIV > Properties > Local Files > Browse Local Files... The executable is named LIV.App.CommandLine.exe.

All usable commands are documented in the executable itself, so refer to that for detailed and current documentation: .\LIV.App.CommandLine.exe help .\LIV.App.CommandLine.exe verb --help

version

EG. .\LIV.App.CommandLine.exe version

Outputs the current LIV Command Line version.

list-apps

EG. .\LIV.App.CommandLine.exe list-apps --human-readable EG. .\LIV.App.CommandLine.exe list-apps --help

Lists all installed and supported LIV titles on the PC. You may filter for a minimum support level (No SDK, SDK, or SDKv1.5). Refer to the command line documentation for more details.