HandJointInfo

struct (plain C++) C++ only

struct AR51SDK_API HandJointInfo;

The hand data model. This page covers the four types that describe a single tracked hand joint and the joint taxonomy around it:

HandJointInfo — the per-joint pose struct (the unit returned by the hands adapter).
EHandJointType — the 23 ordered hand-skeleton joints (Blueprint-exposed).
EHandType — right vs. left.
HandJointTypeHelper — static queries over the joint enum.

HandJointInfo is a plain C++ struct — no USTRUCT macro, not Blueprint-exposed. A platform's hand-tracking backend produces a TArray<HandJointInfo> per hand (one entry per EHandJointType); game code reads it through the IHandsAdapter interface.

Units

Unreal Engine uses centimeters for position and degrees for rotation; the AR 51 native domain uses meters. Every FVector position on these types is in UE centimeters in its respective space. ⚠️ Confirm whether the SDK converts AR 51 meters → UE cm at the adapter boundary, or whether the caller receives raw native units.

HandJointInfo

struct (plain C++) C++ only

struct AR51SDK_API HandJointInfo
{
    EHandType        HandType;
    EHandJointType   JointType;
    float            Confidence;
    FVector          Position;                  // UE cm
    FQuat            Rotation;
    FVector          HmdTrackingSpacePosition;  // UE cm
    FQuat            HmdTrackingSpaceRotation;
};

Plain-old-data describing the pose of a single tracked hand joint. From the SDK doc comment: "Provides information regarding a particular joint in a tracked hand. On platforms where finger-based confidence is not available the overall hand confidence is used. Joints with a confidence of zero are considered missing."

Fields

Field	Type	Description
`HandType`	`EHandType`	which hand this joint belongs to
`JointType`	`EHandJointType`	which joint on that hand
`Confidence`	`float`	tracking confidence; `0` means the joint is missing/untracked. ⚠️ expected range unverified (likely `0..1`, but not asserted in source)
`Position`	`FVector`	resolved (world- or anchor-relative) joint position used by the helpers. UE cm. ⚠️
`Rotation`	`FQuat`	joint orientation matching `Position`
`HmdTrackingSpacePosition`	`FVector`	joint position in the HMD's raw tracking space. UE cm. ⚠️
`HmdTrackingSpaceRotation`	`FQuat`	joint orientation in HMD tracking space

Constructors

Constructor	Use
`HandJointInfo(HandType, JointType)`	"empty" / missing joint
`HandJointInfo(HandType, JointType, Confidence, Position, Rotation)`	single pose (tracking space = working space)
`HandJointInfo(HandType, JointType, Confidence, HmdPos, HmdRot, Position, Rotation)`	full form (distinct HMD-tracking-space + working-space poses)

Static helpers

Method	Returns
`GetConfidentPositions`	`TArray<FVector>`	C++ only
`GetPositions`	`TArray<FVector>`	C++ only
`HasConfidentPositions`	`bool`	C++ only

Constructor details

HandJointInfo(HandType, JointType)

methodconstructor

HandJointInfo(EHandType handType, EHandJointType jointType);

"Empty" joint: Confidence = 0, Position = FVector::ZeroVector, Rotation = FQuat::Identity (and likewise for the HMD-tracking-space fields). Represents a missing joint.

HandJointInfo (single pose)

methodconstructor

HandJointInfo(EHandType handType, EHandJointType jointType,
              float confidence, const FVector& position, const FQuat& rotation);

Sets Position/Rotation and the HmdTrackingSpace* fields to the same supplied values — tracking space is assumed identical to working space.

Parameters

confidencefloattracking confidence (0 = missing). ⚠️ range unverified

positionFVectorjoint position. UE cm. ⚠️

rotationFQuatjoint orientation

HandJointInfo (full form)

methodconstructor

HandJointInfo(EHandType handType, EHandJointType jointType, float confidence,
              const FVector& hmdTrackingSpacePosition, const FQuat& hmdTrackingSpaceRotation,
              const FVector& position, const FQuat& rotation);

Full form: distinct HMD-tracking-space pose (hmdTrackingSpace*) and resolved working-space pose (position/rotation).

Static helper details

GetConfidentPositions

methodstaticC++ only

static TArray<FVector> GetConfidentPositions(const TArray<HandJointInfo>& jointsInfo,
                                             float minimumConfidence);

Returns all joint positions only if the hand passes the confidence gate (see HasConfidentPositions); otherwise returns an empty array. All-or-nothing per hand — there is no per-joint filtering.

Parameters

jointsInfoTArray<HandJointInfo>a whole hand's joints (e.g. from IHandsAdapter::GetRightJointInfos())

minimumConfidencefloatgate applied to the wrist (joint [0]) confidence

ReturnsTArray<FVector>every Position in order if the hand is confident, else empty. UE cm. ⚠️

Exampleinferred

auto* Hands = AdapterFactory<IHandsAdapter>::GetAdapter();
const TArray<HandJointInfo> Right = Hands->GetRightJointInfos();
for (const FVector& P : HandJointInfo::GetConfidentPositions(Right, 0.5f))
{
    // P is in UE cm; empty array means the hand failed the wrist confidence gate
}

GetPositions

methodstaticC++ only

static TArray<FVector> GetPositions(const TArray<HandJointInfo>& jointsInfo);

Extracts every Position into a flat array, preserving joint order. No confidence filtering — missing joints contribute their (zero) positions too.

ReturnsTArray<FVector>all Position values in order. UE cm. ⚠️

HasConfidentPositions

methodstaticC++ only

static bool HasConfidentPositions(const TArray<HandJointInfo>& jointsInfo,
                                  float minimumConfidence);

true when the array is non-empty and the first joint's Confidence >= minimumConfidence.

Wrist proxy

This checks joint [0] — the Wrist — as a proxy for whole-hand confidence, rather than inspecting every joint. GetConfidentPositions uses this same gate. If the wrist is confident, the whole hand is treated as confident.

Returnsbooltrue if the wrist passes the gate

EHandJointType

UENUM · uint8 BlueprintType

UENUM(BlueprintType)
enum class EHandJointType : uint8 { /* … */ };

Enumerates the 23 tracked hand-skeleton joints, ordered Wrist → per-finger chains. Each value carries a UMETA(DisplayName=...) so it reads cleanly in Blueprint dropdowns. The same ordering is what fills a hand's TArray<HandJointInfo> (index 0 is always the wrist).

#	Value	#	Value
0	`Wrist`	12	`MiddleDistal`
1	`ThumbTrapezium`	13	`MiddleTip`
2	`ThumbMetaCarpal`	14	`RingProximal`
3	`ThumbProximal`	15	`RingIntermediate`
4	`ThumbDistal`	16	`RingDistal`
5	`ThumbTip`	17	`RingTip`
6	`IndexProximal`	18	`LittleMetaCarpal`
7	`IndexIntermediate`	19	`LittleProximal`
8	`IndexDistal`	20	`LittleIntermediate`
9	`IndexTip`	21	`LittleDistal`
10	`MiddleProximal`	22	`LittleTip`
11	`MiddleIntermediate`

Chain shape notes:

The thumb has no Intermediate — its chain is ThumbTrapezium → ThumbMetaCarpal → ThumbProximal → ThumbDistal → ThumbTip.
The little finger includes a LittleMetaCarpal that the index/middle/ring do not.
Index / middle / ring each start at Proximal (Proximal → Intermediate → Distal → Tip).

The fingertips (*Tip) are detected by HandJointTypeHelper::IsTip, and per-finger ordered chains are available via the Get*Sequence helpers.

EHandType

enum (plain C++) C++ only

enum EHandType { RightHand = 0, LeftHand = 1 };

Identifies which hand a joint belongs to. This is a plain C++ enum — no UENUM macro, not Blueprint-exposed.

Value	Number
`RightHand`	`0`
`LeftHand`	`1`

HandJointTypeHelper

class (plain C++) C++ only

class AR51SDK_API HandJointTypeHelper;   // static methods only

A static-only utility class of convenience queries over EHandJointType. Not Blueprint-exposed.

Method	Returns
`GetTypes`	`const TArray<EHandJointType>&`	C++ only
`IsTip`	`bool`	C++ only
`Get*Sequence`	`const TArray<EHandJointType>&`	C++ only
`ToString`	`FString`	C++ only

GetTypes

methodstaticC++ only

static const TArray<EHandJointType>& GetTypes();

All joint types, presumably in enum order (Wrist → little tip).

Returnsconst TArray<EHandJointType>&every EHandJointType value. ⚠️ exact contents unverified (defined in HandJointType.cpp)

IsTip

methodstaticC++ only

static bool IsTip(EHandJointType type);

Parameters

typeEHandJointTypea joint type

Returnsbooltrue if the joint is a fingertip (a *Tip value: ThumbTip, IndexTip, MiddleTip, RingTip, LittleTip)

Finger sequences

methodstaticC++ only

static const TArray<EHandJointType>& GetThumbSequence();
static const TArray<EHandJointType>& GetIndexSequence();
static const TArray<EHandJointType>& GetMiddleSequence();
static const TArray<EHandJointType>& GetRingSequence();
static const TArray<EHandJointType>& GetPinkySequence();

The ordered joint chain for one finger, root → tip — useful for drawing bones or walking a finger. Note the naming mismatch: the enum spells the little finger Little*, but this accessor is GetPinkySequence.

Returnsconst TArray<EHandJointType>&the finger's joints in order (e.g. thumb = ThumbTrapezium → … → ThumbTip)

Exampleinferred

const TArray<HandJointInfo> Right = Hands->GetRightJointInfos();
for (EHandJointType J : HandJointTypeHelper::GetIndexSequence())
{
    const HandJointInfo& Info = Right[(int32)J];   // enum value doubles as array index
    UE_LOG(LogTemp, Log, TEXT("%s @ %s"),
        *HandJointTypeHelper::ToString(J), *Info.Position.ToString());
}

ToString

methodstaticC++ only

static FString ToString(EHandJointType handJointType);

Header-inline. Returns the joint's name as a string (e.g. "ThumbTip"), or "Unknown" for unmapped values. Handy for logging / UI.

ReturnsFStringthe joint name, or "Unknown"

HandJointInfo​

Fields​

Constructors​

Static helpers​

Constructor details​

HandJointInfo(HandType, JointType)​

HandJointInfo (single pose)​

HandJointInfo (full form)​

Static helper details​

GetConfidentPositions​

GetPositions​

HasConfidentPositions​

EHandJointType​

EHandType​

HandJointTypeHelper​

GetTypes​

IsTip​

Finger sequences​

ToString​

See also​

HandJointInfo

Fields

Constructors

Static helpers

Constructor details

HandJointInfo(HandType, JointType)

HandJointInfo (single pose)

HandJointInfo (full form)

Static helper details

GetConfidentPositions

GetPositions

HasConfidentPositions

EHandJointType

EHandType

HandJointTypeHelper

GetTypes

IsTip

Finger sequences

ToString

See also