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. Funktionerna är desamma för både Windows Mixed Reality- och OpenXR-system.

Handställning

Med handställning 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 fästingar 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örelsekontrollantdata . Den funktionen returnerar en XRMotionControllerData-struktur . Nedan visas ett skissexempelskript som parsar XRMotionControllerData-strukturen för att hämta gemensamma handplatser och ritar ett felsökningskoordinatsystem på varje joint 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 handbenshierarkin. 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 Windows Mixed Reality för handspårning>:

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

C++:

Inkludera 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ändarnas vänstra eller högra hand.
• Keypoint – benet i handen.
• Transformera – koordinater och orientering av benbasen. Du kan begära basen av nästa ben för att hämta transformeringsdata för slutet av ett ben. Ett speciellt spetsben ger slutet av distala.
• **Radie— radie av benbasen.
• **Returvärde – sant om benet spåras den här ramen, falskt om benet inte spåras.

Hand Live Link-animering

Handställningar exponeras för animering med hjälp av Live Link-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 Handspårningskälla för Windows Mixed Reality

När du har aktiverat källan och öppnat en animeringstillgång expanderar du avsnittet Animering på fliken Förhandsversionsscen och ser även ytterligare alternativ.

Hierarkin för handanimering är densamma som i EWMRHandKeypoint. Animering kan visas på nytt med Hjälp av WindowsMixedRealityHandTrackingLiveLinkRemapAsset:

Den kan också underklasseras 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!

För att få handnät som en spårad geometri i OpenXR måste du anropa Set Use Hand Mesh with Enabled Tracking Geometry (Ange använd handnät med aktiverad spårningsgeometri).

Om du vill aktivera det läget bör du anropa Ange Använd handnät med aktiverad spårningsgeometri:

Kommentar

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

Åtkomst till Hand Mesh-data

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

• Välj din ARSessionConfig-tillgång, expandera AR-Inställningar -> World Mapping-inställningarna och kontrollera Generera meshdata 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 Nav Mesh 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 nät 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 mesh-data 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 skissskådespelare

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:

Hand Mesh-visualisering i OpenXR

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

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, till exempel att rita ett handnät med en anpassad skuggning, måste du få näten som en spårad geometri.

Handstrålar

Att få handställning fungerar för nära interaktioner som att ta tag i objekt eller trycka på knappar. Ibland måste 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 pekande enheter 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 blir de alla anropsbara. Mer information om rena och orena eller anropsbara 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++tar du med WindowsMixedRealityFunctionLibrary.h längst upp i den anropande kodfilen.

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 med lufttryckning, blick och incheckning, eller genom att säga "Välj" med röstinmatning aktiverat.
• Grip – Användaren utlöste griphä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årat – handen är helt spårad

Struct-datatyp

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

• Origin – 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 enligt 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. Hämta pekarepositionsinformation returnerar fullständig information om handstråleriktningen i den aktuella ramen.

Blueprint:

C++:

static FPointerPoseInfo UWindowsMixedRealityFunctionLibrary::GetPointerPoseInfo(EControllerHand hand);

2. Is Gripen returnerar sant om handen greppas 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 spårningsstatus för kontrollant 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 Grundläggande användning för HoloLens 2.

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 Project Inställningar/Engine/Input, 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 gestfångst med CaptureGestures funktionen. När en aktiverad gest utlöser indatahändelser returnerar true funktionen om gestinsamlingen lyckades och false om det finns 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ärnbyggnadsblocken. Härifrån kan du fortsätta till nästa byggblock:

Lokala spatiala fästpunkter

Eller hoppa till funktioner och API:er för Mixed Reality-plattformen:

HoloLens-kamera

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