Skip to main content
Different VR headsets have different performance characteristics. Use device-specific overrides to optimize recording quality and performance.

​
Overview

LCK can automatically apply optimized settings based on the detected VR headset. This ensures the best balance between video quality and game performance.

​
Supported Devices

DeviceMax ResolutionMax FramerateNotes
Meta Quest 21080p HD30 FPSConservative due to thermal limits
Meta Quest 34K UHD60 FPSFull quality support
Meta Quest Pro4K UHD60 FPSFull quality support
PCVR (Windows)4K UHD60 FPSGPU dependent

​
Quest 2 Overrides

Quest 2 has thermal and power constraints that affect encoding performance.

Recommended Quest 2 Settings

​
Applying Quest 2 Overrides

void ApplyQuest2Overrides()
{
    ULCKDeveloperSettings* Settings = ULCKDeveloperSettings::Get();

    // Override quality profiles for Quest 2
    FLCKRecordingProfile& HDProfile = Settings->Profile_HD;
    HDProfile.Framerate = 30;
    HDProfile.VideoBitrate = 10000000;  // 10 Mbps

    // Disable higher quality options
    Settings->bEnable2KProfile = false;
    Settings->bEnable4KProfile = false;
}

​
Quest 3 / Quest Pro Settings

Quest 3 and Quest Pro can handle higher quality settings.
SettingValueNotes
Max Resolution4K (3840x2160)Full support
Framerate60 FPSSmooth encoding
Video Bitrate20 MbpsHigh quality
Audio Bitrate320 kbpsMaximum quality

​
Enabling Full Quality on Quest 3

void EnableQuest3FullQuality()
{
    ULCKDeveloperSettings* Settings = ULCKDeveloperSettings::Get();

    // Enable all quality profiles
    Settings->bEnable2KProfile = true;
    Settings->bEnable4KProfile = true;

    // Set recommended 4K settings
    FLCKRecordingProfile& UHDProfile = Settings->Profile_UHD;
    UHDProfile.Framerate = 60;
    UHDProfile.VideoBitrate = 20000000;  // 20 Mbps
}

​
Automatic Device Detection

LCK can automatically detect the device and apply appropriate overrides: 
void ULCKDeviceManager::ApplyDeviceOverrides()
{
    FString DeviceModel = GetDeviceModel();

    if (DeviceModel.Contains(TEXT("Quest 2")))
    {
        ApplyQuest2Overrides();
        UE_LOG(LogLCK, Log, TEXT("Applied Quest 2 optimizations"));
    }
    else if (DeviceModel.Contains(TEXT("Quest 3")))
    {
        ApplyQuest3Overrides();
        UE_LOG(LogLCK, Log, TEXT("Applied Quest 3 optimizations"));
    }
    else if (DeviceModel.Contains(TEXT("Quest Pro")))
    {
        ApplyQuestProOverrides();
        UE_LOG(LogLCK, Log, TEXT("Applied Quest Pro optimizations"));
    }
    else
    {
        // Use default settings for PCVR
        UE_LOG(LogLCK, Log, TEXT("Using default PCVR settings"));
    }
}

FString ULCKDeviceManager::GetDeviceModel()
{
#if PLATFORM_ANDROID
    // Get Android device model
    return FAndroidMisc::GetDeviceModel();
#else
    // Get VR headset name via OpenXR/SteamVR
    return UHeadMountedDisplayFunctionLibrary::GetHMDDeviceName();
#endif
}

​
Custom Override Configuration

​
Using Config Files

Create device-specific config files: 
; Config/Quest2/DefaultGame.ini
[/Script/LCKCore.LCKDeveloperSettings]
Profile_HD=(Width=1920,Height=1080,Framerate=30,VideoBitrate=10000000)
bEnable2KProfile=false
bEnable4KProfile=false

; Config/Quest3/DefaultGame.ini
[/Script/LCKCore.LCKDeveloperSettings]
Profile_UHD=(Width=3840,Height=2160,Framerate=60,VideoBitrate=20000000)
bEnable2KProfile=true
bEnable4KProfile=true

​
Runtime Configuration

USTRUCT(BlueprintType)
struct FLCKDeviceOverride
{
    GENERATED_BODY()

    UPROPERTY(EditAnywhere)
    FString DeviceModelPattern;

    UPROPERTY(EditAnywhere)
    ELCKVideoQuality MaxQuality;

    UPROPERTY(EditAnywhere)
    int32 MaxFramerate;

    UPROPERTY(EditAnywhere)
    int32 VideoBitrate;
};

UCLASS(Config=Game, DefaultConfig)
class ULCKDeviceSettings : public UDeveloperSettings
{
    GENERATED_BODY()

public:
    UPROPERTY(Config, EditAnywhere, Category = "Device Overrides")
    TArray<FLCKDeviceOverride> DeviceOverrides;
};

​
Performance Monitoring

Monitor encoding performance to validate overrides: 
void ULCKPerformanceMonitor::Tick(float DeltaTime)
{
    if (!IsRecording())
        return;

    // Track frame times
    float FrameTime = FApp::GetDeltaTime() * 1000.0f;
    FrameTimeHistory.Add(FrameTime);

    // Check for performance issues
    float AvgFrameTime = CalculateAverage(FrameTimeHistory);
    if (AvgFrameTime > TargetFrameTime * 1.2f)  // 20% over target
    {
        UE_LOG(LogLCK, Warning, TEXT("Encoding impacting performance: %.1fms avg"),
               AvgFrameTime);

        // Suggest lower quality
        SuggestLowerQuality();
    }
}

void ULCKPerformanceMonitor::SuggestLowerQuality()
{
    OnPerformanceWarning.Broadcast(
        TEXT("Recording may be impacting game performance. "
             "Consider using a lower quality profile.")
    );
}

​
Thermal Management (Android)

On Android, monitor thermal state to prevent throttling: 
#if PLATFORM_ANDROID
void ULCKThermalMonitor::CheckThermalState()
{
    // Android thermal API
    int32 ThermalStatus = FAndroidMisc::GetThermalStatus();

    switch (ThermalStatus)
    {
        case THERMAL_STATUS_NONE:
        case THERMAL_STATUS_LIGHT:
            // Normal operation
            break;

        case THERMAL_STATUS_MODERATE:
            UE_LOG(LogLCK, Warning, TEXT("Device warming up"));
            break;

        case THERMAL_STATUS_SEVERE:
        case THERMAL_STATUS_CRITICAL:
            UE_LOG(LogLCK, Error, TEXT("Thermal throttling - reducing quality"));
            ReduceQualityForThermal();
            break;
    }
}

void ULCKThermalMonitor::ReduceQualityForThermal()
{
    if (ULCKService* Service = GetLCKService())
    {
        // Temporarily reduce to lower quality
        Service->SetQualityProfile(ELCKVideoQuality::SD);
        OnThermalThrottling.Broadcast();
    }
}
#endif

​
Best Practices

Always test recording performance on actual target devices, not just in editor or emulator.
  • Quest 2 has different thermal characteristics than Quest 3
  • PCVR performance depends on GPU
  • Test with demanding game scenes
Let users choose their preferred balance:
UENUM(BlueprintType)
enum class ELCKPerformancePreset : uint8
{
    Quality,      // Highest quality, may impact performance
    Balanced,     // Default, good quality with minimal impact
    Performance   // Lower quality, prioritize game FPS
};
Clearly communicate to players what quality levels work best on their device:
  • In-game tooltips
  • Settings menu descriptions
  • Quality preview before recording

​
See Also

Project Settings

Configure quality profiles

Requirements

Platform requirements