Service components

UCLASS · UActorComponent BlueprintSpawnableComponent singleton

These are the device-side gRPC service endpoints hosted by the SDK actor. The AR 51 connection model is inverted relative to a typical client SDK: your Unreal app runs a set of gRPC servers (these components) and registers itself with OMS. OMS/CVS then call into these services — so most of each component's methods are server-side handlers, not an API you call from Blueprint or C++.

You enable a service simply by adding its component to the AAR51SDK actor; AAR51SDK stands the full set up on its ServicesPort at BeginPlay. What remains caller-facing is small: a couple of lifecycle events, one singleton accessor per component, and one allow-list property on the engine service. Everything else is documented as internal below.

This page covers the service components that have any caller-facing surface plus the four pure endpoints. The spatial-anchor service, which has a substantial public API of its own, has its own page: UAnchorServiceComponent.

Units & space

Unreal world units are centimeters and rotations degrees; AR 51 mocap/CVS data arrives in meters (and a different coordinate convention). Any transform crossing a service boundary is converted by the SDK. To convert yourself, use the helpers on UAnchorServiceComponent (AR51SDKToWorldSpace / WorldToAR51SDKSpace).

UHandSkeletonServiceComponent

UCLASS · UActorComponent BlueprintSpawnableComponent singleton

UCLASS(ClassGroup=(Custom), meta=(BlueprintSpawnableComponent))
class AR51SDK_API UHandSkeletonServiceComponent : public UActorComponent, public ISingleton<UHandSkeletonServiceComponent>

Inherits: UActorComponent (Unreal Engine) · ISingleton<UHandSkeletonServiceComponent>

Hosts the hand-tracking skeleton stream service. Add it to the SDK actor to enable hand tracking. The per-frame hand pose data is delivered through the streaming service itself (consumed elsewhere in the SDK), not via a Blueprint getter on this component — so the caller-facing surface is the start/stop lifecycle events plus the singleton accessor.

Events — UPROPERTY(BlueprintAssignable, Category="Events"), no-param dynamic multicast.

Event	Signature	Fires when
OnHandStreamStarted	FOnHandStreamStarted()	the hand-tracking stream begins
OnHandStreamStopped	FOnHandStreamStarted()	the hand-tracking stream ends

⚠️ delegate-type inconsistency

OnHandStreamStopped is declared with delegate type FOnHandStreamStarted even though an FOnHandStreamStopped type exists. Harmless (both are no-param) but inconsistent — verify before relying on the exact delegate type in C++ binding code.

methodstaticBlueprintCallable

static UHandSkeletonServiceComponent* GetHandSkeletonServiceSingleton();

The live hand-skeleton service instance — the way to reach it from anywhere to bind the stream events.

ReturnsUHandSkeletonServiceComponent*the singleton, or nullptr if none is in the level

Exampleinferred

if (auto* Hands = UHandSkeletonServiceComponent::GetHandSkeletonServiceSingleton())
{
    Hands->OnHandStreamStarted.AddDynamic(this, &AMyManager::HandleHandStreamStarted);
    Hands->OnHandStreamStopped.AddDynamic(this, &AMyManager::HandleHandStreamStopped);
}

Internal — not documented

Server-side gRPC stream handler, not part of the caller-facing API: StartStreaming(grpc::ServerContext*, const AR51::Empty*, grpc::ServerWriter<AR51::TwoHandsInfoResponse>*).

UEngineServiceComponent

UCLASS · UActorComponent BlueprintSpawnableComponent singleton

UCLASS(ClassGroup=(Custom), meta=(BlueprintSpawnableComponent))
class AR51SDK_API UEngineServiceComponent : public UActorComponent, public ISingleton<UEngineServiceComponent>

Inherits: UActorComponent (Unreal Engine) · ISingleton<UEngineServiceComponent>

Hosts the engine / scene-control service — the remote interface OMS/CVS uses to instantiate, transform, parent, name, activate, and re-material actors in the Unreal scene. All of those operations are remote gRPC calls; the one thing you configure from Unreal is the allow-list of Blueprints OMS is permitted to spawn.

Properties — EditAnywhere, BlueprintReadWrite.

Property	Type	Default	Description
General
InstanceBlueprints	TArray<TSubclassOf<AActor>>	—	the set of actor Blueprints OMS is allowed to instantiate (by index/name) through the service

Populate InstanceBlueprints in the Details panel with the actor classes you want OMS to be able to spawn and manipulate remotely; the service can only instantiate classes present in this list.

Internal — not documented

All scene operations are server-side gRPC handlers driven by OMS/CVS, not a Blueprint API you call yourself: GetPyTime, GetPyTimeOffset, SetPyTimeOffset, Instantiate, FindGameObject, FindAnchorGameObject, GetMainCamera, Destroy, CreatePrimitive, NewGameObject, ClearInstances, SetParent, GetName, SetName, GetActive, SetActive, GetTransform, SetTransform, StreamTransform, GetComponent, GetComponentField, SetComponentField, SetCameraProject, SetRendererEnabled, SetMaterialTexture, SetMaterialInt32, SetMaterialFloat, SetMaterialColor, GetMaterialColor; plus the gRPC/proto wire types they use.

Pure service endpoints

These four components are service endpoints only — each exposes the same Get…Singleton() accessor pattern through ISingleton, but has no Blueprint-exposed properties, events, or callable functions in its header (constructor + BeginPlay / TickComponent overrides only). You add them to the SDK actor so OMS can reach the corresponding service; you do not call them from your game code.

Component	Service hosted	Caller-facing Blueprint API
UCameraServiceComponent	camera control / streaming (AR51::CameraService)	none ⚠️
UDrawServiceComponent	scene draw / debug-draw commands (AR51::DrawService)	none
UGameServiceComponent	game-control hooks (AR51::GameService)	none
URenderServiceComponent	render control / streaming (AR51::RenderService)	none

All four are UCLASS · UActorComponent (BlueprintSpawnableComponent) and ISingleton<…>.

⚠️ camera developer API

UCameraServiceComponent has no caller-facing API on the component itself. Any camera-facing developer API likely lives elsewhere (e.g. the engine service or a camera adapter), not here — confirm before assuming this component is the entry point for camera control.

See also

• AAR51SDK — the connection entry-point actor that hosts every service component
• UAnchorServiceComponent — the spatial-anchor / boundary service (its own public API, including the space-conversion helpers)
• USkeletonConsumer — the skeleton-stream consumer (the main mocap entry point)
• EPlatformTypes — device/platform class reported at registration
• Class index — all Unreal SDK types