Integration

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.

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

Recommended Initialization Sequence

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

Subsystem returns nullptr

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;
}

Callbacks not firing

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"));
}

Widget not rendering

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();

Core SDK API Reference

ULCKService API reference

Spawning

Best practices for tablet spawning

Overview

Accessing LCK Service

Via World Subsystem

From Any Actor

Blueprint Access

Tablet Lifecycle

Spawning

Destruction

Lifecycle Events

Enabling Grabbing

Widget Component Setup

ULCKWidgetComponent

Collision Setup

Weak Pointer Patterns

TWeakObjectPtr Pattern

TWeakPtr for Shared Pointers

Event Subscription

Safe Delegate Binding

Initialization Order

Recommended Initialization Sequence

Troubleshooting Integration

See Also

Core SDK API Reference

Spawning

​Overview

​Accessing LCK Service

​Via World Subsystem

​From Any Actor

​Blueprint Access

​Tablet Lifecycle

​Spawning

​Destruction

​Lifecycle Events

​Enabling Grabbing

​Widget Component Setup

​ULCKWidgetComponent

​Collision Setup

​Weak Pointer Patterns

​TWeakObjectPtr Pattern

​TWeakPtr for Shared Pointers

​Event Subscription

​Safe Delegate Binding

​Initialization Order

​Recommended Initialization Sequence

​Troubleshooting Integration

​See Also

Core SDK API Reference

Spawning

Overview

Accessing LCK Service

Via World Subsystem

From Any Actor

Blueprint Access

Tablet Lifecycle

Spawning

Destruction

Lifecycle Events

Enabling Grabbing

Widget Component Setup

ULCKWidgetComponent

Collision Setup

Weak Pointer Patterns

TWeakObjectPtr Pattern

TWeakPtr for Shared Pointers

Event Subscription

Safe Delegate Binding

Initialization Order

Recommended Initialization Sequence

Troubleshooting Integration

See Also