Skip to main content

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.

​
Overview

This guide covers accessing the LCK subsystem and service, tablet actor lifecycle, widget component setup, and async callback patterns.

​
Accessing LCK Service

​
Via World Subsystem

The recommended way to access LCK functionality: 
ULCKSubsystem* GetLCKSubsystem(UWorld* World)
{
    if (World)
    {
        return World->GetSubsystem<ULCKSubsystem>();
    }
    return nullptr;
}

ULCKService* GetLCKService(UWorld* World)
{
    if (ULCKSubsystem* Subsystem = GetLCKSubsystem(World))
    {
        return Subsystem->GetService();
    }
    return nullptr;
}

​
From Any Actor

void AMyActor::UseRecording()
{
    ULCKSubsystem* Subsystem = GetWorld()->GetSubsystem<ULCKSubsystem>();
    if (!Subsystem)
    {
        UE_LOG(LogTemp, Error, TEXT("LCK Subsystem not available"));
        return;
    }

    ULCKService* Service = Subsystem->GetService();
    if (Service)
    {
        Service->StartRecording();
    }
}

​
Blueprint Access

UFUNCTION(BlueprintCallable, Category = "LCK", meta = (WorldContext = "WorldContextObject"))
static ULCKService* GetLCKService(UObject* WorldContextObject)
{
    if (UWorld* World = GEngine->GetWorldFromContextObject(WorldContextObject, EGetWorldErrorMode::LogAndReturnNull))
    {
        if (ULCKSubsystem* Subsystem = World->GetSubsystem<ULCKSubsystem>())
        {
            return Subsystem->GetService();
        }
    }
    return nullptr;
}

​
Tablet Lifecycle

​
Spawning

void AMyGameMode::SpawnLCKTablet()
{
    if (!TabletClass)
    {
        UE_LOG(LogTemp, Error, TEXT("TabletClass not set"));
        return;
    }

    FVector SpawnLocation = GetTabletSpawnLocation();
    FRotator SpawnRotation = FRotator::ZeroRotator;

    FActorSpawnParameters SpawnParams;
    SpawnParams.SpawnCollisionHandlingOverride =
        ESpawnActorCollisionHandlingMethod::AdjustIfPossibleButAlwaysSpawn;

    SpawnedTablet = GetWorld()->SpawnActor<ALCKTablet>(
        TabletClass,
        SpawnLocation,
        SpawnRotation,
        SpawnParams
    );

    if (SpawnedTablet)
    {
        OnTabletSpawned(SpawnedTablet);
    }
}

​
Destruction

void AMyGameMode::DestroyLCKTablet()
{
    if (SpawnedTablet)
    {
        // Stop any active recording first
        if (ULCKService* Service = GetLCKService(GetWorld()))
        {
            if (Service->IsRecording())
            {
                Service->StopRecording();
            }
        }

        SpawnedTablet->Destroy();
        SpawnedTablet = nullptr;
    }
}

​
Lifecycle Events

void ALCKTablet::BeginPlay()
{
    Super::BeginPlay();

    // Load saved settings
    LoadSettings();

    // Initialize camera
    InitializeCamera();

    // Register with telemetry
    if (ULCKTelemetrySubsystem* Telemetry = GetGameInstance()->GetSubsystem<ULCKTelemetrySubsystem>())
    {
        FLCKTelemetryEvent Event;
        Event.EventType = ELCKTelemetryEventType::CameraEnabled;
        Telemetry->SendTelemetry(Event);
    }
}

void ALCKTablet::EndPlay(const EEndPlayReason::Type EndPlayReason)
{
    // Save current settings
    SaveSettings();

    // Stop any active recording
    if (ULCKService* Service = GetLCKService(GetWorld()))
    {
        if (Service->IsRecording())
        {
            Service->StopRecording();
        }
    }

    // Telemetry
    if (ULCKTelemetrySubsystem* Telemetry = GetGameInstance()->GetSubsystem<ULCKTelemetrySubsystem>())
    {
        FLCKTelemetryEvent Event;
        Event.EventType = ELCKTelemetryEventType::CameraDisabled;
        Telemetry->SendTelemetry(Event);
    }

    Super::EndPlay(EndPlayReason);
}

​
Enabling Grabbing

The UI doesn’t handle grabbing mechanics. Grabbing is game-specific and it’s up to developers to integrate. Here’s an example using the GrabComponent from Unreal’s VR Template. Make sure you call GrabStarted and GrabEnded methods on LCKTablet. You can set them up in C++ or Blueprint. GrabComponent setup

​
Widget Component Setup

​
ULCKWidgetComponent

The tablet uses a widget component for its 3D UI: 
UCLASS()
class ALCKTablet : public ALCKTabletUI
{
    GENERATED_BODY()

    // Components are inherited from ALCKTabletUI:
    // - UStaticMeshComponent* TabletRoot (root mesh)
    // - USceneCaptureComponent2D* CaptureComponent (video source)
    // - ULCKUISystem* UISystem (3D UI management)
    // - ULCKDisplay* Display (render target display)

public:
    // Constructor — components are created by parent ALCKTabletUI
    // Do not create TabletRoot, CaptureComponent, UISystem, or Display manually
};

​
Collision Setup

void ALCKTablet::SetupCollision()
{
    // Configure collision for VR hand interaction
    TabletMesh->SetCollisionProfileName(TEXT("OverlapOnlyPawn"));
    TabletMesh->SetGenerateOverlapEvents(true);

    // Set custom collision responses
    TabletMesh->SetCollisionResponseToChannel(
        ECC_Pawn,
        ECR_Overlap
    );
}

​
Weak Pointer Patterns

For safe async callbacks, always use weak pointers:

​
TWeakObjectPtr Pattern

void UMyComponent::StartRecordingWithCallback()
{
    ULCKService* Service = GetLCKService(GetWorld());
    if (!Service)
    {
        return;
    }

    // Capture weak pointer to this
    TWeakObjectPtr<UMyComponent> WeakThis(this);

    bool bSuccess = Service->StartRecording();
    HandleRecordingStarted(bSuccess);
}

void UMyComponent::HandleRecordingStarted(bool bSuccess)
{
    if (bSuccess)
    {
        UpdateUIForRecording();
    }
    else
    {
        ShowRecordingError();
    }
}

​
TWeakPtr for Shared Pointers

void FMyAudioHandler::BindToSource(TSharedPtr<ILCKAudioSource> Source)
{
    TWeakPtr<FMyAudioHandler> WeakThis = AsShared();

    Source->OnAudioDataDelegate.BindLambda(
        [WeakThis](TArrayView<const float> PCM, int32 Channels, int32 SampleRate, ELCKAudioChannel SourceChannel)
        {
            if (TSharedPtr<FMyAudioHandler> This = WeakThis.Pin())
            {
                This->ProcessAudio(PCM, Channels, SampleRate, SourceChannel);
            }
        }
    );
}

​
Event Subscription

​
Safe Delegate Binding

void UMyWidget::NativeConstruct()
{
    Super::NativeConstruct();

    // Find tablet and bind to events
    if (ALCKTablet* Tablet = FindLCKTablet())
    {
        ULCKTabletDataModel* DataModel = Tablet->GetDataModel();

        // Store binding handle for cleanup
        RecordingStateHandle = DataModel->OnRecordStateChanged.AddUObject(
            this, &UMyWidget::OnRecordingStateChanged
        );

        CameraModeHandle = DataModel->OnTabletCameraModeChanged.AddUObject(
            this, &UMyWidget::OnCameraModeChanged
        );
    }
}

void UMyWidget::NativeDestruct()
{
    // Unbind all delegates
    if (ALCKTablet* Tablet = FindLCKTablet())
    {
        ULCKTabletDataModel* DataModel = Tablet->GetDataModel();
        DataModel->OnRecordStateChanged.Remove(RecordingStateHandle);
        DataModel->OnTabletCameraModeChanged.Remove(CameraModeHandle);
    }

    Super::NativeDestruct();
}

​
Initialization Order

void ALCKTablet::BeginPlay()
{
    Super::BeginPlay();

    // 1. Create and initialize data model
    DataModel = NewObject<ULCKTabletDataModel>(this);
    DataModel->Initialize();

    // 2. Load saved settings
    LoadSettings();

    // 3. Initialize camera system (CaptureComponent is inherited from ALCKTabletUI)
    InitializeCameraCapture();

    // 5. Bind to service events
    BindToServiceEvents();

    // 6. Send spawn telemetry
    SendSpawnTelemetry();
}

​
Troubleshooting Integration

Cause: World not valid or subsystem not registered.Solution:
// Ensure world is valid
if (!GetWorld())
{
    UE_LOG(LogLCK, Error, TEXT("No world available"));
    return;
}

// Check if game is still running
if (GetWorld()->bIsTearingDown)
{
    return;
}
Cause: Object destroyed before callback or delegate unbound.Solution: Use weak pointers and verify binding:
// Verify delegate is bound
if (Service->OnRecordingError.IsBound())
{
    UE_LOG(LogLCK, Log, TEXT("Delegate properly bound"));
}
Cause: Widget component not properly configured.Solution:
TabletWidget->SetWidgetSpace(EWidgetSpace::World);
TabletWidget->SetDrawSize(FVector2D(800, 600));
TabletWidget->SetTwoSided(true);  // Visible from both sides
TabletWidget->RequestRedraw();

​
See Also

Core SDK API Reference

ULCKService API reference

Spawning

Best practices for tablet spawning