Enums Reference (Unreal) - LCK Documentation

What Problem Does This Solve?

Enums define fixed sets of values used throughout LCK:

Recording states (Idle, Recording, Saving)
Video quality presets (SD, HD, 2K, 4K)
Audio channel types (Game, Microphone, VoiceChat)
Screen orientation (Landscape, Portrait)
UI states (Default, Hovered, Pressed)

Understanding these enums helps you check states, configure settings, and handle events correctly.

When to Use This

Reference this when:

Checking recording state
Setting video quality
Configuring audio channels
Setting screen orientation
Handling UI interactions
Debugging enum-related issues

Recording & Capture

ELCKRecordingState

What it’s for: Current state of the recording system

UENUM(BlueprintType)
enum class ELCKRecordingState : uint8
{
    Idle        UMETA(DisplayName = "Idle"),
    Recording   UMETA(DisplayName = "Recording"),
    Saving      UMETA(DisplayName = "Saving"),
    Processing  UMETA(DisplayName = "Processing"),
    Error       UMETA(DisplayName = "Error"),
    Paused      UMETA(DisplayName = "Paused")
};

State	Description	What You Can Do
`Idle`	No recording active, ready to start	Start recording, change settings
`Recording`	Actively recording video/audio	Stop recording, pause, take photo
`Saving`	Finalizing and saving file to disk	Wait for completion
`Processing`	Post-processing video (rare)	Wait for completion
`Error`	An error occurred	Check error message, retry
`Paused`	Recording paused	Resume or stop

State machine flow:

Idle -> Recording -> Saving -> Idle
         |                      ^
       Error --------------------

Common usage:

// Recording state is available on ULCKService
ELCKRecordingState State = Service->GetRecordingState();

switch (State)
{
    case ELCKRecordingState::Idle:
        // Show "Start Recording" button
        break;
    case ELCKRecordingState::Recording:
        // Show recording indicator, enable "Stop" button
        break;
    case ELCKRecordingState::Saving:
        // Show progress bar
        break;
    case ELCKRecordingState::Error:
        // Show error message
        break;
}

ELCKVideoQuality

What it’s for: Predefined quality profile selection

UENUM(BlueprintType)
enum class ELCKVideoQuality : uint8
{
    SD      UMETA(DisplayName = "SD"),
    HD      UMETA(DisplayName = "HD"),
    TWO_K   UMETA(DisplayName = "2K"),
    FOUR_K  UMETA(DisplayName = "4K"),
    MAX     UMETA(Hidden)
};

Quality	Resolution	Video Bitrate	Audio Bitrate	FPS	Use Case
`SD`	1280x720	4 Mbps	128 Kbps	30	Mobile VR, performance mode
`HD`	1920x1080	12 Mbps	256 Kbps	60	Standard quality (recommended)
`TWO_K`	2560x1440	20 Mbps	320 Kbps	60	High quality
`FOUR_K`	3840x2160	35 Mbps	320 Kbps	60	Maximum quality (PC only)

Quest recommendations:

Quest 2: Use HD (1080p) for best balance
Quest 3/Pro: Can handle 2K if performance allows
Avoid 4K on Quest devices

Usage:

// Video quality is managed through ULCKTabletDataModel, not ULCKService
ULCKTabletDataModel* DataModel = Tablet->GetDataModel();

// Set quality profile
DataModel->SetVideoQuality(ELCKVideoQuality::HD);

// Get current quality
ELCKVideoQuality Current = DataModel->GetCurrentVideoQuality();

// Cycle through quality levels (SD -> HD -> 2K -> 4K -> SD)
DataModel->CycleVideoQuality();

ELCKScreenOrientation

What it’s for: Video output orientation

UENUM(BlueprintType)
enum class ELCKScreenOrientation : uint8
{
    Landscape   UMETA(DisplayName = "Landscape"),
    Portrait    UMETA(DisplayName = "Portrait")
};

Orientation	Aspect Ratio	Resolution Example	Use Case
`Landscape`	16:9 (horizontal)	1920x1080	YouTube, traditional video
`Portrait`	9:16 (vertical)	1080x1920	TikTok, Instagram Stories

Usage:

// Screen orientation is managed through ULCKTabletDataModel, not ULCKService
ULCKTabletDataModel* DataModel = Tablet->GetDataModel();

// Set orientation
DataModel->SetScreenOrientation(ELCKScreenOrientation::Portrait);

// Get current orientation
ELCKScreenOrientation Current = DataModel->GetScreenOrientation();

// Toggle between Landscape and Portrait
DataModel->ToggleScreenOrientation();

Camera Modes

UClass-Based Camera Mode System

Camera modes are not selected via an enum. The LCK SDK uses a UClass*-based system where each camera mode is a subclass of ULCKBaseCameraMode.

The three built-in camera mode classes are:

Class	Description	Use Case
`ULCKSelfieCameraMode`	Front/back facing camera attached to tablet	Vlog-style, show player’s face
`ULCKFirstPersonCameraMode`	POV from player’s HMD position	Gameplay perspective
`ULCKThirdPersonCameraMode`	Orbital camera following player	Cinematic, show player character

Usage:

// Camera mode is managed through ULCKTabletDataModel
ULCKTabletDataModel* DataModel = Tablet->GetDataModel();

// Switch camera mode by passing the UClass*
DataModel->SetCameraMode(ULCKThirdPersonCameraMode::StaticClass());

// Get current camera mode class
UClass* CurrentMode = DataModel->GetCameraMode();

// Check which mode is active
if (CurrentMode->IsChildOf(ULCKSelfieCameraMode::StaticClass()))
{
    // Selfie mode is active
}

ELCKCameraFacing

What it’s for: Selfie camera direction

UENUM(BlueprintType)
enum class ELCKCameraFacing : uint8
{
    Front   UMETA(DisplayName = "Front"),
    Rear    UMETA(DisplayName = "Rear")
};

Value	Description
`Front`	Camera faces toward player (like front camera on phone)
`Rear`	Camera faces away from player (like back camera on phone)

Only applies to Selfie mode. Usage:

ULCKTabletDataModel* DataModel = Tablet->GetDataModel();

// Set camera facing
DataModel->SetSelfieCameraFacing(ELCKCameraFacing::Rear);

// Toggle between Front and Rear
DataModel->ToggleSelfieCameraFacing();

Audio System

ELCKAudioChannel

What it’s for: Audio source types for capture and mixing

enum ELCKAudioChannel : uint64
{
    None       = 0,           // No audio
    Game       = 1,           // Game audio output
    Microphone = 1 << 1,      // Microphone input
    VoiceChat  = 1 << 2,      // Voice chat (Vivox)
    Max        = 1 << 3       // Marker (don't use)
};

Channel	Bit	Description	Sources
`None`	0	No audio	-
`Game`	1	Game audio output	UnrealAudio, FMOD, Wwise, Vivox (incoming)
`Microphone`	2	Microphone input	UnrealAudio, Oboe, Vivox (outgoing)
`VoiceChat`	4	Voice chat (reserved)	Not currently used

LCKVivox mapping:

Incoming voice chat -> Game channel
Outgoing microphone -> Microphone channel

Bitwise operations:

// Combine channels
TLCKAudioChannelsMask Channels =
    ELCKAudioChannel::Game | ELCKAudioChannel::Microphone;

// Check if channel is in mask
bool HasMic = (Channels & ELCKAudioChannel::Microphone) != 0;

// Remove a channel
Channels &= ~ELCKAudioChannel::Microphone;

// Add a channel
Channels |= ELCKAudioChannel::VoiceChat;

ELCKMicState

What it’s for: Microphone state for recording

UENUM(BlueprintType)
enum class ELCKMicState : uint8
{
    On          UMETA(DisplayName = "On"),
    Off         UMETA(DisplayName = "Off"),
    No_Access   UMETA(DisplayName = "No Access")
};

State	Description	UI Action
`On`	Microphone enabled and capturing	Show “Mic On” indicator
`Off`	Microphone disabled	Show “Mic Off” indicator
`No_Access`	Permission denied (Android)	Prompt user to grant permission

On Android, No_Access means the user denied microphone permission. You must guide them to device settings to grant the permission.

Usage:

// Mic state is managed through ULCKTabletDataModel
ULCKTabletDataModel* DataModel = Tablet->GetDataModel();

ELCKMicState MicState = DataModel->GetMicState();

switch (MicState)
{
    case ELCKMicState::On:
        MicIcon->SetBrush(MicOnTexture);
        break;
    case ELCKMicState::Off:
        MicIcon->SetBrush(MicOffTexture);
        break;
    case ELCKMicState::No_Access:
        ShowPermissionPrompt();
        break;
}

// Toggle mic on/off
DataModel->ToggleMicState();

// Set mic state directly
DataModel->SetMicState(ELCKMicState::Off);

ELCKGameAudioType

What it’s for: Detected game audio middleware

UENUM(BlueprintType)
enum class ELCKGameAudioType : uint8
{
    None        UMETA(DisplayName = "None"),
    FMOD        UMETA(DisplayName = "FMOD"),
    Wwise       UMETA(DisplayName = "Wwise"),
    UnrealAudio UMETA(DisplayName = "Unreal Audio")
};

Type	Description	Priority
`None`	No game audio capture	-
`FMOD`	FMOD Studio middleware	1 (highest)
`Wwise`	Audiokinetic Wwise middleware	2
`UnrealAudio`	Built-in Unreal Engine audio	3 (lowest)

Priority order: FMOD > Wwise > UnrealAudio Only ONE game audio source is active at a time.

Usage:

// Check which audio middleware is active
ELCKGameAudioType ActiveAudio = Settings->GetActiveGameAudioType();

switch (ActiveAudio)
{
    case ELCKGameAudioType::FMOD:
        UE_LOG(LogLCK, Log, TEXT("Using FMOD for game audio"));
        break;
    case ELCKGameAudioType::Wwise:
        UE_LOG(LogLCK, Log, TEXT("Using Wwise for game audio"));
        break;
    case ELCKGameAudioType::UnrealAudio:
        UE_LOG(LogLCK, Log, TEXT("Using Unreal Audio"));
        break;
}

UI Components

ELCKButtonType

What it’s for: Button shape and size for 3D UI

UENUM(BlueprintType)
enum class ELCKButtonType : uint8
{
    Square      UMETA(DisplayName = "Square"),
    Rectangle   UMETA(DisplayName = "Rectangle"),
    Tab         UMETA(DisplayName = "Tab"),
    Selector    UMETA(DisplayName = "Selector")
};

Type	Dimensions (cm)	Aspect	Use Case
`Square`	(0.4, 2.4, 2.4)	1:1	Icons, single-action
`Rectangle`	(0.4, 6.0, 2.4)	2.5:1	Text buttons, labels
`Tab`	(0.4, 4.4, 2.4)	1.83:1	Tab navigation
`Selector`	(2.4, 4.4, 0.8)	5.5:1	Sliders, selectors

Button States

Button interaction states are managed via method calls and material parameters rather than a centralized enum. The key mechanisms are:

bIsEnabled (bool) — Controls whether the button accepts interaction
ButtonPressed(const FLCKTapData&) — Called on overlap begin (press)
ButtonReleased(const FLCKTapData&) — Called on overlap end (release)
UpdateVisualsOnPressed() / UpdateVisualsOnReleased() — Virtual methods for visual state transitions

Visual feedback is applied via dynamic material parameters (BackColor, FrontColor, IndicatorValue) and mesh position offsets.

ELCKButtonInteractionDirection

What it’s for: Touch validation direction for buttons

UENUM(BlueprintType)
enum class ELCKButtonInteractionDirection : uint8
{
    Forward     UMETA(DisplayName = "Forward"),
    Up          UMETA(DisplayName = "Up")
};

Value	Description	Use Case
`Forward`	Press from front of button	Standard VR interaction
`Up`	Press from above button	Horizontal surfaces (table-mounted)

Telemetry

ELCKTelemetryEventType

What it’s for: Analytics events sent to LCK Dashboard

UENUM(BlueprintType)
enum class ELCKTelemetryEventType : uint8
{
    GameInitialized   UMETA(DisplayName = "Game Initialized"),
    ServiceCreated    UMETA(DisplayName = "Service Created"),
    ServiceDisposed   UMETA(DisplayName = "Service Disposed"),
    CameraEnabled     UMETA(DisplayName = "Camera Enabled"),
    CameraDisabled    UMETA(DisplayName = "Camera Disabled"),
    RecordingStarted  UMETA(DisplayName = "Recording Started"),
    RecordingStopped  UMETA(DisplayName = "Recording Stopped"),
    PhotoCaptured     UMETA(DisplayName = "Photo Captured"),
    PhotoCaptureError UMETA(DisplayName = "Photo Capture Error"),
    RecorderError     UMETA(DisplayName = "Recorder Error"),
    SdkError          UMETA(DisplayName = "SDK Error"),
    Performance       UMETA(DisplayName = "Performance"),
    StreamingStarted  UMETA(DisplayName = "Streaming Started"),
    StreamingStopped  UMETA(DisplayName = "Streaming Stopped"),
    StreamingError    UMETA(DisplayName = "Streaming Error")
};

Value	Description
`GameInitialized`	Game has initialized the SDK
`ServiceCreated`	LCK Service instance created
`ServiceDisposed`	LCK Service instance disposed
`CameraEnabled`	Camera capture enabled
`CameraDisabled`	Camera capture disabled
`RecordingStarted`	Recording started
`RecordingStopped`	Recording stopped
`PhotoCaptured`	Photo captured successfully
`PhotoCaptureError`	Photo capture failed
`RecorderError`	Recording error occurred
`SdkError`	General SDK error
`Performance`	Performance metrics event
`StreamingStarted`	Live streaming started
`StreamingStopped`	Live streaming stopped
`StreamingError`	Live streaming error occurred

Telemetry is automatic. You don’t need to manually send these events unless building custom analytics.

Enum Usage Examples

Quality Selection UI

void AQualitySelector::OnQualityButtonPressed(ELCKVideoQuality Quality)
{
    // Visual feedback
    switch (Quality)
    {
        case ELCKVideoQuality::SD:
            QualityLabel->SetText(FText::FromString("SD (720p)"));
            break;
        case ELCKVideoQuality::HD:
            QualityLabel->SetText(FText::FromString("HD (1080p)"));
            break;
        case ELCKVideoQuality::TWO_K:
            QualityLabel->SetText(FText::FromString("2K (1440p)"));
            break;
        case ELCKVideoQuality::FOUR_K:
            QualityLabel->SetText(FText::FromString("4K (2160p)"));
            break;
    }

    // Apply via DataModel (not Service)
    DataModel->SetVideoQuality(Quality);
}

Recording State Handler

void ARecordingUI::OnRecordingStateChanged(ELCKRecordingState NewState)
{
    switch (NewState)
    {
        case ELCKRecordingState::Idle:
            RecordButton->SetEnabled(true);
            RecordButton->SetText(FText::FromString("Start Recording"));
            ProgressBar->SetVisibility(ESlateVisibility::Collapsed);
            break;

        case ELCKRecordingState::Recording:
            RecordButton->SetEnabled(true);
            RecordButton->SetText(FText::FromString("Stop Recording"));
            RecordingIndicator->SetVisibility(ESlateVisibility::Visible);
            break;

        case ELCKRecordingState::Saving:
            RecordButton->SetEnabled(false);
            ProgressBar->SetVisibility(ESlateVisibility::Visible);
            StatusText->SetText(FText::FromString("Saving..."));
            break;

        case ELCKRecordingState::Error:
            RecordButton->SetEnabled(true);
            ShowErrorDialog(ErrorMessage);
            break;
    }
}

Key Takeaways

ELCKRecordingState — Track recording lifecycle (Idle -> Recording -> Saving)

ELCKVideoQuality — Predefined quality presets (SD, HD, 2K, 4K)

ELCKAudioChannel — Bitwise flags for audio sources (Game, Mic, VoiceChat)

Camera modes use UClass* — ULCKSelfieCameraMode, ULCKFirstPersonCameraMode, ULCKThirdPersonCameraMode

ELCKMicState — Handle microphone on/off/no access

Settings live on ULCKTabletDataModel — Quality, orientation, mic state, and camera mode are managed through DataModel, not ULCKService

Types & Structs — Struct definitions
Error Codes — Error handling
Architecture — How enums are used in the system

​What Problem Does This Solve?

​When to Use This

​Recording & Capture

​ELCKRecordingState

​ELCKVideoQuality

​ELCKScreenOrientation

​Camera Modes

​UClass-Based Camera Mode System

​ELCKCameraFacing

​Audio System

​ELCKAudioChannel

​ELCKMicState

​ELCKGameAudioType

​UI Components

​ELCKButtonType

​Button States

​ELCKButtonInteractionDirection

​Telemetry

​ELCKTelemetryEventType

​Enum Usage Examples

​Quality Selection UI

​Recording State Handler

​Key Takeaways

​Related

What Problem Does This Solve?

When to Use This

Recording & Capture

ELCKRecordingState

ELCKVideoQuality

ELCKScreenOrientation

Camera Modes

UClass-Based Camera Mode System

ELCKCameraFacing

Audio System

ELCKAudioChannel

ELCKMicState

ELCKGameAudioType

UI Components

ELCKButtonType

Button States

ELCKButtonInteractionDirection

Telemetry

ELCKTelemetryEventType

Enum Usage Examples

Quality Selection UI

Recording State Handler

Key Takeaways

Related