> ## Documentation Index
> Fetch the complete documentation index at: https://docs.liv.tv/llms.txt
> Use this file to discover all available pages before exploring further.

# Enums Reference (Unreal)

> Complete enumeration reference for the LCK SDK for Unreal Engine.

## 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

```cpp theme={null}
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:**

```cpp theme={null}
// 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

```cpp theme={null}
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)      |

<Info>
  **Quest recommendations:**

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

**Usage:**

```cpp theme={null}
// 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

```cpp theme={null}
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:**

```cpp theme={null}
// 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

<Warning>
  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`.
</Warning>

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:**

```cpp theme={null}
// 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

```cpp theme={null}
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:**

```cpp theme={null}
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

```cpp theme={null}
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                         |

<Info>
  **LCKVivox mapping:**

  * Incoming voice chat -> `Game` channel
  * Outgoing microphone -> `Microphone` channel
</Info>

**Bitwise operations:**

```cpp theme={null}
// 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

```cpp theme={null}
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 |

<Warning>
  On Android, `No_Access` means the user denied microphone permission. You must guide them to device settings to grant the permission.
</Warning>

**Usage:**

```cpp theme={null}
// 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

```cpp theme={null}
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)  |

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

**Usage:**

```cpp theme={null}
// 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

```cpp theme={null}
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

```cpp theme={null}
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

```cpp theme={null}
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 |

<Info>
  Telemetry is automatic. You don't need to manually send these events unless building custom analytics.
</Info>

***

## Enum Usage Examples

### Quality Selection UI

```cpp theme={null}
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

```cpp theme={null}
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

<Check>**ELCKRecordingState** -- Track recording lifecycle (Idle -> Recording -> Saving)</Check>
<Check>**ELCKVideoQuality** -- Predefined quality presets (SD, HD, 2K, 4K)</Check>
<Check>**ELCKAudioChannel** -- Bitwise flags for audio sources (Game, Mic, VoiceChat)</Check>
<Check>**Camera modes use UClass**\* -- ULCKSelfieCameraMode, ULCKFirstPersonCameraMode, ULCKThirdPersonCameraMode</Check>
<Check>**ELCKMicState** -- Handle microphone on/off/no access</Check>
<Check>**Settings live on ULCKTabletDataModel** -- Quality, orientation, mic state, and camera mode are managed through DataModel, not ULCKService</Check>

***

## Related

* [Types & Structs](/api-reference/unreal/types) -- Struct definitions
* [Error Codes](/api-reference/unreal/errors) -- Error handling
* [Architecture](/api-reference/unreal/architecture) -- How enums are used in the system