Handspårning i Unreal

Handspårningssystemet använder en persons handflator och fingrar som indata. Data om position och rotation av varje finger, hela handflatan och handgester är tillgängliga. Från och med Unreal 4.26 baseras handspårning på plugin-programmet Unreal HeadMountedDisplay och använder ett gemensamt API på alla XR-plattformar och enheter. Funktionaliteten är densamma för både Windows Mixed Reality- och OpenXR-system.

Handposition

Med handposition kan du spåra och använda användarnas händer och fingrar som indata, som kan nås i både Skisser och C++. Unreal-API:et skickar data som ett koordinatsystem, med tick synkroniserade med Unreal Engine.

4.26

Hierarkin beskrivs med EHandKeypoint uppräkning:

Du kan hämta alla dessa data från en användares händer med hjälp av funktionen Hämta rörelsestyrenhetsdata . Den funktionen returnerar en XRMotionControllerData-struktur . Nedan visas ett skissexempelskript som parsar XRMotionControllerData-strukturen för att få gemensamma handplatser och ritar ett system för felsökningskoordinater på varje gemensam plats.

Det är viktigt att kontrollera om strukturen är giltig och att den är en hand. Annars kan du få odefinierat beteende vid åtkomst till positioner, rotationer och radii-matriser.

4.25

Uppräkningen EWMRHandKeypoint beskriver handens benhierarki. Du hittar varje handnyckelpunkt i skisserna:

Hela C++-uppräkningen visas nedan:

enum class EWMRHandKeypoint : uint8
{
	Palm,
	Wrist,
	ThumbMetacarpal,
	ThumbProximal,
	ThumbDistal,
	ThumbTip,
	IndexMetacarpal,
	IndexProximal,
	IndexIntermediate,
	IndexDistal,
	IndexTip,
	MiddleMetacarpal,
	MiddleProximal,
	MiddleIntermediate,
	MiddleDistal,
	MiddleTip,
	RingMetacarpal,
	RingProximal,
	RingIntermediate,
	RingDistal,
	RingTip,
	LittleMetacarpal,
	LittleProximal,
	LittleIntermediate,
	LittleDistal,
	LittleTip
};

Du hittar de numeriska värdena för varje uppräkningsfall i Windows.Perception.Personer. HandJointKind-tabell.

Stöd för handspårning

Du kan använda handspårning i skisser genom att lägga till Stöd för handspårning från handspårning > Windows Mixed Reality:

Den här funktionen returnerar true om handspårning stöds på enheten och false om handspårning inte är tillgängligt.

C++:

Ta med WindowsMixedRealityHandTrackingFunctionLibrary.h.

static bool UWindowsMixedRealityHandTrackingFunctionLibrary::SupportsHandTracking()

Hämta handspårning

Du kan använda GetHandJointTransform för att returnera rumsliga data från handen. Data uppdateras varje bildruta, men om du befinner dig i en ram cachelagras de returnerade värdena. Vi rekommenderar inte att du har tung logik i den här funktionen av prestandaskäl.

C++:

static bool UWindowsMixedRealityHandTrackingFunctionLibrary::GetHandJointTransform(EControllerHand Hand, EWMRHandKeypoint Keypoint, FTransform& OutTransform, float& OutRadius)

Här är en uppdelning av GetHandJointTransforms funktionsparametrar:

• Hand – kan vara användarens vänstra eller högra hand.
• Keypoint – benet i handen.
• Transform – koordinater och orientering av benets bas. Du kan begära basen av nästa ben för att hämta transformeringsdata för slutet av ett ben. En speciell Tip ben ger slutet av distala.
• **Radie – benbasens radie.
• **Returvärde – sant om benet spåras denna ram, falskt om benet inte spåras.

Animering av livelänkar för hand

Handställningar exponeras för animering med livelänk-plugin-programmet.

Om plugin-programmet Windows Mixed Reality och Live Link är aktiverade:

1. Välj Windows > Live Link för att öppna fönstret Live Link-redigeraren.
2. Välj Källa och aktivera Windows Mixed Reality handspårningskälla

När du har aktiverat källan och öppnat en animeringstillgång expanderar du avsnittet Animering på fliken Förhandsgranskningsscen för att se ytterligare alternativ.

Hierarkin för handanimering är samma som i EWMRHandKeypoint. Animering kan omdirigeras med WindowsMixedRealityHandTrackingLiveLinkRemapAsset:

Den kan också underklassas i redigeraren:

Handnät

Viktigt

Handnät kräver OpenXR.

Microsoft OpenXR-plugin-programmet måste användas, tillgängligt från Unreal Marketplace eller GitHub.

Handnät som en spårad geometri

Viktigt

Att hämta handnät som en spårad geometri i OpenXR kräver att du anropar Set Use Hand Mesh med aktiverad spårningsgeometri.

Om du vill aktivera det läget bör du anropa Set Use Hand Mesh with Enabled Tracking Geometry (Ange Använd handnät med aktiverad spårningsgeometri):

Anteckning

Det går inte att aktivera båda lägena samtidigt. Om du aktiverar den ena inaktiveras den andra automatiskt.

Komma åt handnätsdata

Innan du kan komma åt handnätsdata måste du:

• Välj din ARSessionConfig-tillgång , expandera AR Settings - World Mapping settings (AR-inställningar för> världsmappning ) och markera Generate Mesh Data from Tracked Geometry (Generera mesh-data från spårad geometri).

Nedan visas standardparametrarna för nät:

1. Använda Mesh-data för ocklusion
2. Generera kollision för Mesh-data
3. Generera navnät för Mesh-data
4. Rendera Mesh-data i Wireframe – felsökningsparameter som visar genererat nät

Dessa parametervärden används som standardvärden för spatial mappning och handnät. Du kan ändra dem när som helst i Skisser eller kod för valfritt nät.

C++ API-referens

Använd EEARObjectClassification för att hitta handnätvärden i alla spårbara objekt.

enum class EARObjectClassification : uint8
{
    // Other types
	HandMesh,
};

Följande ombud anropas när systemet identifierar spårbara objekt, inklusive ett handnät.

class FARSupportInterface
{
    public:
    // Other params
	DECLARE_AR_SI_DELEGATE_FUNCS(OnTrackableAdded)
	DECLARE_AR_SI_DELEGATE_FUNCS(OnTrackableUpdated)
	DECLARE_AR_SI_DELEGATE_FUNCS(OnTrackableRemoved)
};

Kontrollera att dina ombudshanterare följer funktionssignaturen nedan:

void UARHandMeshComponent::OnTrackableAdded(UARTrackedGeometry* Added)

Du kan komma åt nätdata via UARTrackedGeometry::GetUnderlyingMesh:

UMRMeshComponent* UARTrackedGeometry::GetUnderlyingMesh()

Skiss-API-referens

Så här arbetar du med handnät i skisser:

1. Lägga till en ARTrackableNotify-komponent i en skissaktör

2. Gå till panelen Information och expandera avsnittet Händelser .

3. Skriv över vid lägg till/uppdatera/ta bort spårad geometri med följande noder i händelsediagrammet:

Visualisering av handnät i OpenXR

Det rekommenderade sättet att visualisera handnät är att använda Epics XRVisualization-plugin-program tillsammans med Plugin-programmet Microsoft OpenXR.

I skissredigeraren bör du sedan använda funktionen Set Use Hand Mesh från Microsoft OpenXR-plugin-programmet med Aktiverad XRVisualization som parameter:

Om du vill hantera renderingsprocessen bör du använda Render Motion Controller från XRVisualization:

Resultatet:

Om du behöver något mer komplicerat, som att rita ett handnät med en anpassad skuggning, måste du få näten som en spårad geometri.

Handstrålar

Att hämta handställning fungerar för nära interaktioner som att ta tag i objekt eller trycka på knappar. Ibland behöver du dock arbeta med hologram som är långt borta från användarna. Detta kan åstadkommas med handstrålar, som kan användas som pekare i både C++ och Blueprints. Du kan rita en stråle från handen till en avlägsen punkt och, med lite hjälp från Unreal ray tracing, välja ett hologram som annars skulle vara utom räckhåll.

Viktigt

Eftersom alla funktionsresultat ändrar varje bildruta görs alla anropbara. Mer information om rena och orena eller anropbara funktioner finns i Skissanvändar-GUID för funktioner.

4.26

Om du vill hämta data för handstrålarna bör du använda funktionen Hämta rörelsestyrenhetsdata från föregående avsnitt. Den returnerade strukturen innehåller två parametrar som du kan använda för att skapa en handstråle – Aim Position och Aim Rotation. Dessa parametrar bildar en stråle som styrs av armbågen. Du bör ta dem och hitta ett hologram som pekas av.

Nedan visas ett exempel på hur du avgör om en handstråle träffar en widget och anger ett anpassat träffresultat:

4.25

Om du vill använda handstrålar i skisser söker du efter någon av åtgärderna under Windows Mixed Reality HMD:

Om du vill komma åt dem i C++, inkludera WindowsMixedRealityFunctionLibrary.h längst upp i din kodfil för samtal.

Enum

Du har också åtkomst till indatafall under EHMDInputControllerButtons, som kan användas i Skisser:

Använd uppräkningsklassen EHMDInputControllerButtons för åtkomst i C++:

enum class EHMDInputControllerButtons : uint8
{
	Select,
	Grasp,
//......
};

Nedan visas en uppdelning av de två tillämpliga uppräkningsfallen:

• Välj – Användaren utlöste Välj händelse.
  • Utlöses i HoloLens 2 av lufttryck, blick och incheckning, eller genom att säga "Välj" med röstinmatning aktiverat.
• Grip – Användaren utlöste Grip-händelsen.
  • Utlöses i HoloLens 2 genom att stänga användarens fingrar på ett hologram.

Du kan komma åt spårningsstatusen för ditt handnät i C++ via uppräkningen EHMDTrackingStatus nedan:

enum class EHMDTrackingStatus : uint8
{
	NotTracked,
	//......
	Tracked
};

Nedan visas en uppdelning av de två tillämpliga uppräkningsfallen:

• NotTracked – handen är inte synlig
• Spåras – handen är helt spårad

Struct-datatyp

PointerPoseInfo-structen kan ge dig information om följande handdata:

• Ursprung – handens ursprung
• Riktning – handriktningen
• Upp – upp vektor av handen
• Orientering – quaternion för orientering
• Spårningsstatus – aktuell spårningsstatus

Du kan komma åt PointerPoseInfo-structen via skisser, som du ser nedan:

Eller med C++:

struct FPointerPoseInfo
{
	FVector Origin;
	FVector Direction;
	FVector Up;
	FQuat Orientation;
	EHMDTrackingStatus TrackingStatus;
};

Functions

Alla funktioner som anges nedan kan anropas på varje bildruta, vilket möjliggör kontinuerlig övervakning.

1. Get Pointer Pose Info returnerar fullständig information om handstråleriktningen i den aktuella ramen.

Blueprint:

C++:

static FPointerPoseInfo UWindowsMixedRealityFunctionLibrary::GetPointerPoseInfo(EControllerHand hand);

2. Is Grasped returnerar sant om handen är förstådd i den aktuella ramen.

Blueprint:

C++:

static bool UWindowsMixedRealityFunctionLibrary::IsGrasped(EControllerHand hand);

3. Är Select Pressed returnerar sant om användaren utlöste Välj i den aktuella ramen.

Blueprint:

C++:

static bool UWindowsMixedRealityFunctionLibrary::IsSelectPressed(EControllerHand hand);

4. Är knappen klickad returnerar sant om händelsen eller knappen utlöses i den aktuella ramen.

Blueprint:

C++:

static bool UWindowsMixedRealityFunctionLibrary::IsButtonClicked(EControllerHand hand, EHMDInputControllerButtons button);

5. Hämta status för kontrollantspårning returnerar spårningsstatusen i den aktuella ramen.

Blueprint:

C++:

static EHMDTrackingStatus UWindowsMixedRealityFunctionLibrary::GetControllerTrackingStatus(EControllerHand hand);

Gester

HoloLens 2 spårar rumsliga gester, vilket innebär att du kan fånga dessa gester som indata. Gestspårning baseras på en prenumerationsmodell. Du bör använda funktionen "Konfigurera gester" för att tala om för enheten vilka gester du vill spåra. Mer information om gester finns i dokumentet HoloLens 2 Grundläggande användning.

4.26

Windows Mixed Reality

Sedan bör du lägga till kod för att prenumerera på följande händelser:

OpenXR

I OpenXR spåras gesthändelser via indatapipelinen. Med hjälp av handinteraktion kan enheten automatiskt känna igen tryck- och hållgester, men inte de andra. De namnges som OpenXRMsftHandInteraction Select- och Grip-mappningar. Du behöver inte aktivera prenumerationen. Du bör deklarera händelserna i Projektinställningar/Motor/Indata, precis så här:

4.25

Du hittar funktionen Blueprint i under Windows Mixed Reality Spatial Input och C++-funktionen genom att lägga till WindowsMixedRealitySpatialInputFunctionLibrary.h i din anropande kodfil.

Enum

Blueprint:

C++:

enum class ESpatialInputAxisGestureType : uint8
{
	None = 0,
	Manipulation = 1,
	Navigation = 2,
	NavigationRails = 3
};

Funktion

Du kan aktivera och inaktivera gestinsamling med CaptureGestures funktionen . När en aktiverad gest utlöser indatahändelser returnerar true funktionen om gestavbildningen lyckades och false om det uppstår ett fel.

Blueprint:

C++:

static bool UWindowsMixedRealitySpatialInputFunctionLibrary::CaptureGestures(
	bool Tap = false,
	bool Hold = false,
	ESpatialInputAxisGestureType AxisGesture = ESpatialInputAxisGestureType::None,
	bool NavigationAxisX = true,
	bool NavigationAxisY = true,
	bool NavigationAxisZ = true);

Följande är viktiga händelser som du hittar i Skisser och C++:

const FKey FSpatialInputKeys::TapGesture(TapGestureName);
const FKey FSpatialInputKeys::DoubleTapGesture(DoubleTapGestureName);
const FKey FSpatialInputKeys::HoldGesture(HoldGestureName);

const FKey FSpatialInputKeys::LeftTapGesture(LeftTapGestureName);
const FKey FSpatialInputKeys::LeftDoubleTapGesture(LeftDoubleTapGestureName);
const FKey FSpatialInputKeys::LeftHoldGesture(LeftHoldGestureName);

const FKey FSpatialInputKeys::RightTapGesture(RightTapGestureName);
const FKey FSpatialInputKeys::RightDoubleTapGesture(RightDoubleTapGestureName);
const FKey FSpatialInputKeys::RightHoldGesture(RightHoldGestureName);

const FKey FSpatialInputKeys::LeftManipulationGesture(LeftManipulationGestureName);
const FKey FSpatialInputKeys::LeftManipulationXGesture(LeftManipulationXGestureName);
const FKey FSpatialInputKeys::LeftManipulationYGesture(LeftManipulationYGestureName);
const FKey FSpatialInputKeys::LeftManipulationZGesture(LeftManipulationZGestureName);

const FKey FSpatialInputKeys::LeftNavigationGesture(LeftNavigationGestureName);
const FKey FSpatialInputKeys::LeftNavigationXGesture(LeftNavigationXGestureName);
const FKey FSpatialInputKeys::LeftNavigationYGesture(LeftNavigationYGestureName);
const FKey FSpatialInputKeys::LeftNavigationZGesture(LeftNavigationZGestureName);


const FKey FSpatialInputKeys::RightManipulationGesture(RightManipulationGestureName);
const FKey FSpatialInputKeys::RightManipulationXGesture(RightManipulationXGestureName);
const FKey FSpatialInputKeys::RightManipulationYGesture(RightManipulationYGestureName);
const FKey FSpatialInputKeys::RightManipulationZGesture(RightManipulationZGestureName);

const FKey FSpatialInputKeys::RightNavigationGesture(RightNavigationGestureName);
const FKey FSpatialInputKeys::RightNavigationXGesture(RightNavigationXGestureName);
const FKey FSpatialInputKeys::RightNavigationYGesture(RightNavigationYGestureName);
const FKey FSpatialInputKeys::RightNavigationZGesture(RightNavigationZGestureName);

Nästa kontrollpunkt för utveckling

Om du följer unreal-utvecklingsresan som vi har lagt fram är du mitt uppe i att utforska MRTK-kärnbyggstenarna. Härifrån kan du fortsätta till nästa byggblock:

Lokala spatiala fästpunkter

Eller gå vidare till Mixed Reality plattformsfunktioner och API:er:

HoloLens-kamera

Du kan alltid gå tillbaka till kontrollpunkterna för Unreal-utveckling när som helst.