Handtracking in Unreal

Das Handverfolgungssystem verwendet die Handflächen und Finger einer Person als Eingabe. Daten zur Position und Drehung jedes Fingers, der gesamten Handfläche und der Handgesten sind verfügbar. Ab Unreal 4.26 basiert die Handverfolgung auf dem Unreal HeadMountedDisplay-Plug-In und verwendet eine gemeinsame API für alle XR-Plattformen und -Geräte. Die Funktionalität ist für Windows Mixed Reality- und OpenXR-Systeme identisch.

Handhaltung

Mit Handhaltung können Sie die Hände und Finger Ihrer Benutzer als Eingabe nachverfolgen und verwenden, auf die sowohl in Blaupausen als auch in C++ zugegriffen werden kann. Die Unreal-API sendet die Daten als Koordinatensystem, wobei Ticks mit der Unreal Engine synchronisiert werden.

4.26

Die Hierarchie wird durch EHandKeypoint Aufzählung beschrieben:

Sie können alle diese Daten aus den Händen eines Benutzers abrufen, indem Sie die Funktion Get Motion Controller Data verwenden. Diese Funktion gibt eine XRMotionControllerData-Struktur zurück. Im Folgenden finden Sie ein Blaupausen-Beispielskript, das die XRMotionControllerData-Struktur analysiert, um handgelenkte Speicherorte abzurufen und ein Debugkoordinatensystem an der Position jedes Gelenks zu zeichnet.

Es ist wichtig, zu überprüfen, ob die Struktur gültig ist und ob es sich um eine Hand handelt. Andernfalls erhalten Sie möglicherweise ein undefiniertes Verhalten beim Zugriff auf Positionen, Drehungen und Radienarrays.

4.25

Die EWMRHandKeypoint Enumeration beschreibt die Knochenhierarchie der Hand. Sie finden jeden Handschlüsselpunkt, der in Ihren Blaupausen aufgeführt ist:

Die vollständige C++-Enumeration ist unten aufgeführt:

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

Die numerischen Werte für jeden Enumerationsfall finden Sie im Windows.Perception.Personen. HandJointKind-Tabelle.

Unterstützung der Handnachverfolgung

Sie können die Handnachverfolgung in Blaupausen verwenden, indem Sie Unterstützung der Handnachverfolgung von hand tracking from Hand Tracking > Windows Mixed Reality hinzufügen:

Diese Funktion gibt zurück true , wenn die Handnachverfolgung auf dem Gerät unterstützt wird und false die Handnachverfolgung nicht verfügbar ist.

C++:

Schließen Sie WindowsMixedRealityHandTrackingFunctionLibrary.h ein.

static bool UWindowsMixedRealityHandTrackingFunctionLibrary::SupportsHandTracking()

Abrufen der Handnachverfolgung

Sie können GetHandJointTransform verwenden, um räumliche Daten von der Hand zurückzugeben. Die Daten aktualisieren jeden Frame, aber wenn Sie sich in einem Frame befinden, werden die zurückgegebenen Werte zwischengespeichert. Es wird aus Leistungsgründen nicht empfohlen, eine starke Logik in dieser Funktion zu verwenden.

C++:

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

Im Folgenden finden Sie eine Aufschlüsselung der GetHandJointTransform-Funktionsparameter:

• Hand – kann der Benutzer links oder rechts sein.
• Keypoint – der Knochen der Hand.
• Transformieren : Koordinaten und Ausrichtung der Knochenbasis. Sie können die Basis des nächsten Knochens anfordern, um die Transformationsdaten für das Ende eines Knochens abzurufen. Ein spezieller Tip-Knochen gibt das Ende des distalen.
• **Radius: Radius der Basis des Knochens.
• **Rückgabewert – true, wenn der Knochen diesen Frame nachverfolgt, false, wenn der Knochen nicht nachverfolgt wird.

Hand-Livelinkanimation

Handhaltungen werden mithilfe des Live Link-Plug-Ins für Animation verfügbar gemacht.

Wenn die Windows Mixed Reality- und Live Link-Plug-Ins aktiviert sind:

1. Wählen Sie Fenster > Livelink aus, um das Fenster Live Link-Editor zu öffnen.
2. Wählen Sie Quelle aus, und aktivieren Sie Windows Mixed Reality Handverfolgungsquelle.

Nachdem Sie die Quelle aktiviert und ein Animationsobjekt geöffnet haben, erweitern Sie den Abschnitt Animation auf der Registerkarte Vorschauszene . Weitere Optionen finden Sie ebenfalls.

Die Handanimationshierarchie ist identisch mit der in EWMRHandKeypoint. Animationen können mithilfe von WindowsMixedRealityHandTrackingLiveLinkRemapAsset neu zugewiesen werden:

Sie kann auch im Editor unterklassiert werden:

Handgitter

Wichtig

Handgitter erfordert OpenXR.

Das Microsoft OpenXR-Plug-In muss verwendet werden, verfügbar über den Unreal Marketplace oder über GitHub.

Handgitter als nachverfolgte Geometrie

Wichtig

Um Handgitter als nachverfolgte Geometrie in OpenXR zu erhalten, müssen Sie Set Use Hand Mesh with Enabled Tracking Geometry aufrufen.

Um diesen Modus zu aktivieren, sollten Sie Set Use Hand Mesh with Enabled Tracking Geometry aufrufen:

Hinweis

Es ist nicht möglich, dass beide Modi gleichzeitig aktiviert werden. Wenn Sie einen aktivieren, wird die andere automatisch deaktiviert.

Zugreifen auf Handgitterdaten

Bevor Sie auf Handgitterdaten zugreifen können, müssen Sie Folgendes ausführen:

• Wählen Sie Ihre ARSessionConfig-Ressource aus, erweitern Sie die EINSTELLUNGEN FÜR AR-Einstellungen –> Weltzuordnung , und aktivieren Sie Gitterdaten aus nachverfolgter Geometrie generieren.

Im Folgenden finden Sie die Standardgitterparameter:

1. Verwenden von Mesh Data for Occlusion
2. Generieren von Kollisionen für Gitterdaten
3. Generieren von Nav Mesh für Gitterdaten
4. Rendern von Gitterdaten im Wireframe – Debugparameter, der generiertes Gitter anzeigt

Diese Parameterwerte werden als Räumliche Zuordnungsgitter und Handgitterstandard verwendet. Sie können sie jederzeit in Blaupausen oder Code für jedes Gitter ändern.

C++-API-Referenz

Verwenden Sie EEARObjectClassification , um Handgitterwerte in allen nachverfolgbaren Objekten zu finden.

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

Die folgenden Delegatten werden aufgerufen, wenn das System ein nachverfolgbares Objekt erkennt, einschließlich eines Handgitters.

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

Stellen Sie sicher, dass Ihre Delegathandler die folgende Funktionssignatur befolgen:

void UARHandMeshComponent::OnTrackableAdded(UARTrackedGeometry* Added)

Sie können über folgendes UARTrackedGeometry::GetUnderlyingMeshauf Gitterdaten zugreifen:

UMRMeshComponent* UARTrackedGeometry::GetUnderlyingMesh()

Blaupausen-API-Referenz

So arbeiten Sie mit Handgittern in Blaupausen:

1. Hinzufügen einer ARTrackableNotify-Komponente zu einem Blaupausenschauspieler

2. Wechseln Sie zum Bereich Details , und erweitern Sie den Abschnitt Ereignisse .

3. Überschreiben Sie beim Hinzufügen/Aktualisieren/Entfernen nachverfolgter Geometrie mit den folgenden Knoten in Ihrem Ereignisdiagramm:

Handgittervisualisierung in OpenXR

Die empfohlene Möglichkeit zum Visualisieren von Handgittern ist die Verwendung des XRVisualization-Plug-Ins von Epic zusammen mit dem Microsoft OpenXR-Plug-In.

Anschließend sollten Sie im Blaupausen-Editor die Set Use Hand Mesh-Funktion aus dem Microsoft OpenXR-Plug-In mit Enabled XRVisualization als Parameter verwenden:

Um den Renderingprozess zu verwalten, sollten Sie Render Motion Controller von XRVisualization verwenden:

Das Ergebnis:

Wenn Sie etwas komplizierteres benötigen, z. B. das Zeichnen eines Handgitters mit einem benutzerdefinierten Shader, müssen Sie die Gitter als nachverfolgte Geometrie abrufen.

Handlichtstrahl

Das Abrufen von Handpose funktioniert für enge Interaktionen wie das Greifen von Objekten oder das Drücken von Tasten. Manchmal müssen Sie jedoch mit Hologrammen arbeiten, die weit von Ihren Benutzern entfernt sind. Dies kann mit Handstrahlen erreicht werden, die als Zeigegeräte in C++ und Blaupausen verwendet werden können. Sie können einen Strahl von Ihrer Hand bis zu einem weit entfernten Punkt zeichnen und mithilfe von Unreal Raytracing ein Hologramm auswählen, das andernfalls unerreichbar wäre.

Wichtig

Da alle Funktionsergebnisse jeden Frame ändern, werden sie alle aufrufbar gemacht. Weitere Informationen zu reinen und unreinen oder aufrufbaren Funktionen finden Sie in der Blaupausenbenutzer-GUId für Funktionen.

4.26

Um die Daten für die Handstrahlen abzurufen, sollten Sie die Funktion Get Motion Controller Data aus dem vorherigen Abschnitt verwenden. Die zurückgegebene Struktur enthält zwei Parameter, die Sie zum Erstellen eines Handstrahls verwenden können: Zielposition und Zielrotation. Diese Parameter bilden einen Strahl, der von Ihrem Ellenbogen gesteuert wird. Sie sollten sie nehmen und ein Hologramm finden, an dem gezeigt wird.

Im Folgenden finden Sie ein Beispiel für die Bestimmung, ob ein Handstrahl auf ein Widget trifft, und ein benutzerdefiniertes Trefferergebnis festlegen:

4.25

Um Handstrahlen in Blaupausen zu verwenden, suchen Sie nach einer der Aktionen unter Windows Mixed Reality HMD:

Um in C++ darauf zuzugreifen, fügen Sie WindowsMixedRealityFunctionLibrary.h oben in die aufrufende Codedatei ein.

Enumeration

Sie haben auch Zugriff auf Eingabefälle unter EHMDInputControllerButtons, die in Blueprints verwendet werden können:

Verwenden Sie für den Zugriff in C++ die EHMDInputControllerButtons Enumerationsklasse:

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

Im Folgenden finden Sie eine Aufschlüsselung der beiden anwendbaren Fälle:

• Select : Vom Benutzer ausgelöstes Select-Ereignis.
  • Wird in HoloLens 2 durch Luftkippen, Blicken und Commit oder durch "Auswählen" bei aktivierter Spracheingabe ausgelöst.
• Grasp : Vom Benutzer ausgelöstes Grasp-Ereignis.
  • Wird in HoloLens 2 ausgelöst, indem die Finger des Benutzers auf einem Hologramm geschlossen werden.

Sie können auf die Nachverfolgung status Ihres Handgitters in C++ über die EHMDTrackingStatus unten gezeigte Aufzählung zugreifen:

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

Im Folgenden finden Sie eine Aufschlüsselung der beiden anwendbaren Fälle:

• NotTracked – die Hand ist nicht sichtbar
• Nachverfolgt – die Hand wird vollständig nachverfolgt

Struktur

Die PointerPoseInfo-Struktur kann Ihnen Informationen zu den folgenden Handdaten liefern:

• Ursprung – Ursprung der Hand
• Richtung – Richtung der Hand
• Nach oben – nach oben Vektor der Hand
• Orientierung – Orientierungsquaternion
• Nachverfolgungsstatus – aktuelle status

Sie können über Blaupausen auf die PointerPoseInfo-Struktur zugreifen, wie unten gezeigt:

Oder mit C++:

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

Funktionen

Alle unten aufgeführten Funktionen können für jeden Frame aufgerufen werden, was eine kontinuierliche Überwachung ermöglicht.

1. Get Pointer Pose Info gibt vollständige Informationen zur Handstrahlrichtung im aktuellen Frame zurück.

Blueprint:

C++:

static FPointerPoseInfo UWindowsMixedRealityFunctionLibrary::GetPointerPoseInfo(EControllerHand hand);

2. Is Grasped gibt true zurück, wenn die Hand im aktuellen Frame erfasst wird.

Blueprint:

C++:

static bool UWindowsMixedRealityFunctionLibrary::IsGrasped(EControllerHand hand);

3. Is Select Pressed gibt true zurück, wenn der Benutzer Select im aktuellen Frame ausgelöst hat.

Blueprint:

C++:

static bool UWindowsMixedRealityFunctionLibrary::IsSelectPressed(EControllerHand hand);

4. Is Button Clicked gibt true zurück, wenn das Ereignis oder die Schaltfläche im aktuellen Frame ausgelöst wird.

Blueprint:

C++:

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

5. Controllernachverfolgungsstatus abrufen gibt den status im aktuellen Frame zurück.

Blueprint:

C++:

static EHMDTrackingStatus UWindowsMixedRealityFunctionLibrary::GetControllerTrackingStatus(EControllerHand hand);

Gesten

Die HoloLens 2 verfolgt räumliche Gesten nach, was bedeutet, dass Sie diese Gesten als Eingabe erfassen können. Die Gestennachverfolgung basiert auf einem Abonnementmodell. Sie sollten die Funktion "Gesten konfigurieren" verwenden, um dem Gerät mitzuteilen, welche Gesten Sie nachverfolgen möchten. Weitere Details zu Gesten finden Sie im Dokument HoloLens 2 Grundlegende Verwendung.

4.26

Windows Mixed Reality

Anschließend sollten Sie Code hinzufügen, um die folgenden Ereignisse zu abonnieren:

OpenXR

In OpenXR werden Gestenereignisse über die Eingabepipeline nachverfolgt. Mithilfe der Handinteraktion kann das Gerät Tap-and-Hold-Gesten automatisch erkennen, aber nicht die anderen. Sie werden als OpenXRMsftHandInteraction Select- und Grip-Zuordnungen benannt. Sie müssen das Abonnement nicht aktivieren. Sie sollten die Ereignisse in Projekteinstellungen/Engine/Eingabe wie folgt deklarieren:

4.25

Sie finden die Blaupausenfunktion unter Windows Mixed Reality Räumliche Eingabe und die C++-Funktion, indem Sie ihre aufrufende Codedatei hinzufügenWindowsMixedRealitySpatialInputFunctionLibrary.h.

Enumeration

Blueprint:

C++:

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

Funktion

Sie können die Gestenerfassung mit der CaptureGestures Funktion aktivieren und deaktivieren. Wenn eine aktivierte Geste Eingabeereignisse auslöst, gibt die Funktion zurück true , wenn die Gestenerfassung erfolgreich war und false ein Fehler vorliegt.

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

Im Folgenden finden Sie wichtige Ereignisse, die Sie unter Blaupausen und C++: finden.

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ächster Entwicklungsprüfpunkt

Wenn Sie der Unreal-Entwicklungs-Journey folgen, die wir entworfen haben, befinden Sie sich mitten im Kennenlernen der MRTK-Grundbausteine. Von hier aus können Sie mit dem nächsten Baustein fortfahren:

Lokale Raumanker

Oder fahren Sie mit den Funktionen und APIs der Mixed Reality-Plattform fort:

HoloLens-Kamera

Sie können jederzeit zu den Prüfpunkten für die Unreal-Entwicklung zurückkehren.