Suivi de la main dans Unreal

Le système de suivi des mains utilise les paumes et les doigts d’une personne comme entrée. Les données sur la position et la rotation de chaque doigt, la paume entière et les mouvements de main sont disponibles. À compter d’Unreal 4.26, le suivi des mains est basé sur le plug-in Unreal HeadMountedDisplay et utilise une API commune sur toutes les plateformes et appareils XR. La fonctionnalité est la même pour les systèmes Windows Mixed Reality et OpenXR.

Pose manuelle

La pose manuelle vous permet de suivre et d’utiliser les mains et les doigts de vos utilisateurs comme entrée, qui sont accessibles à la fois dans Blueprints et C++. L’API Unreal envoie les données en tant que système de coordonnées, avec des graduations synchronisées avec le moteur Unreal.

4.26

La hiérarchie est décrite par EHandKeypoint énumération :

Vous pouvez obtenir toutes ces données à partir des mains d’un utilisateur à l’aide de la fonction Obtenir les données du contrôleur de mouvement. Cette fonction retourne une structure XRMotionControllerData . Vous trouverez ci-dessous un exemple de script Blueprint qui analyse la structure XRMotionControllerData pour obtenir des emplacements de jointure manuelle et dessine un système de coordonnées de débogage à l’emplacement de chaque joint.

Il est important de case activée si la structure est valide et qu’elle est une main. Sinon, vous pouvez obtenir un comportement non défini dans l’accès aux positions, rotations et tableaux de radii.

4.25

L’énumération EWMRHandKeypoint décrit la hiérarchie osseuse de la main. Vous trouverez chaque point clé de main répertorié dans vos blueprints :

L’énumération C++ complète est répertoriée ci-dessous :

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

Vous trouverez les valeurs numériques pour chaque cas d’énumération dans Windows.Perception.Personnes. Table HandJointKind.

Prise en charge du suivi des mains

Vous pouvez utiliser le suivi des mains dans Blueprints en ajoutant Supports Hand Tracking à partir de Hand Tracking > Windows Mixed Reality :

Cette fonction retourne true si le suivi des mains est pris en charge sur l’appareil et false si le suivi des mains n’est pas disponible.

C++ :

Inclure WindowsMixedRealityHandTrackingFunctionLibrary.h.

static bool UWindowsMixedRealityHandTrackingFunctionLibrary::SupportsHandTracking()

Obtention du suivi des mains

Vous pouvez utiliser GetHandJointTransform pour retourner des données spatiales de la main. Les données mettez à jour chaque image, mais si vous êtes à l’intérieur d’une image, les valeurs retournées sont mises en cache. Il n’est pas recommandé d’avoir une logique lourde dans cette fonction pour des raisons de performances.

C++ :

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

Voici une répartition des paramètres de fonction de GetHandJointTransform :

• Main : il peut s’agir des utilisateurs de gauche ou de droite.
• Point clé : l’os de la main.
• Transformation : coordonnées et orientation de la base de l’os. Vous pouvez demander la base de l’os suivant pour obtenir les données de transformation pour la fin d’un os. Un os de pointe spécial donne fin de distal.
• **Rayon : rayon de la base de l’os.
• **Valeur de retour : true si l’os est suivi de ce cadre, false si l’os n’est pas suivi.

Hand Live Link Animation

Les poses manuelles sont exposées à Animation à l’aide du plug-in Live Link.

Si les plug-ins Windows Mixed Reality et Live Link sont activés :

1. Sélectionnez Fenêtre > Live Link pour ouvrir la fenêtre de l’éditeur Live Link.
2. Sélectionnez Source et activez la source de suivi des mains Windows Mixed Reality

Une fois que vous avez activé la source et ouvert une ressource d’animation, développez la section Animation sous l’onglet Scène d’aperçu , voir également des options supplémentaires.

La hiérarchie d’animation manuelle est la même que dans EWMRHandKeypoint. L’animation peut être retargetée à l’aide de WindowsMixedRealityHandTrackingLiveLinkRemapAsset :

Il peut également être sous-classé dans l’éditeur :

Maille à main

Important

Le maillage de main nécessite OpenXR.

Vous devez télécharger le plug-in Microsoft OpenXR, disponible sur la marketplace Unreal ou GitHub.

Maille manuelle en tant que géométrie suivie

Important

L’obtention de maillages de main en tant que géométrie suivie dans OpenXR vous oblige à appeler Set Use Hand Mesh with Enabled Tracking Geometry.

Pour activer ce mode, vous devez appeler Set Hand Mesh avec enabled Tracking Geometry :

Remarque

Il n’est pas possible que les deux modes soient activés en même temps. Si vous activez l’un, l’autre est automatiquement désactivé.

Accès aux données Hand Mesh

Avant de pouvoir accéder aux données de maillage de main, vous devez :

• Sélectionnez votre ressource ARSessionConfig, développez les paramètres AR Paramètres -> World Mapping et case activée Générer des données mesh à partir d’une géométrie suivie.

Voici les paramètres de maillage par défaut :

1. Utiliser mesh Data for Occlusion
2. Générer une collision pour les données mesh
3. Générer une maille de navigation pour les données mesh
4. Render Mesh Data in Wireframe : paramètre de débogage qui affiche le maillage généré

Ces valeurs de paramètre sont utilisées comme maillage de mappage spatial et les valeurs par défaut du maillage de la main. Vous pouvez les modifier à tout moment dans Blueprints ou code pour n’importe quel maillage.

Informations de référence sur l’API C++

Permet EEARObjectClassification de rechercher des valeurs de maillage de main dans tous les objets pouvant être suivis.

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

Les délégués suivants sont appelés lorsque le système détecte tout objet pouvant être suivi, y compris un maillage de main.

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

Assurez-vous que vos gestionnaires délégués suivent la signature de fonction ci-dessous :

void UARHandMeshComponent::OnTrackableAdded(UARTrackedGeometry* Added)

Vous pouvez accéder aux données de maillage par le biais des UARTrackedGeometry::GetUnderlyingMeshpoints suivants :

UMRMeshComponent* UARTrackedGeometry::GetUnderlyingMesh()

Informations de référence sur l’API Blueprint

Pour utiliser des maillages main dans des blueprints :

1. Ajouter un composant ARTrackableNotify à un acteur blueprint

2. Accédez au panneau Détails et développez la section Événements .

3. Remplacer sur l’extension/mise à jour/supprimer la géométrie suivie avec les nœuds suivants dans votre graphique d’événements :

Visualisation Hand Mesh dans OpenXR

La méthode recommandée pour visualiser le maillage de main consiste à utiliser le plug-in XRVisualization d’Epic avec le plug-in Microsoft OpenXR.

Ensuite, dans l’éditeur de blueprint, vous devez utiliser la fonction Set Use Hand Mesh à partir du plug-in Microsoft OpenXR avec Enabled XRVisualization comme paramètre :

Pour gérer le processus de rendu, vous devez utiliser Render Motion Controller à partir de XRVisualization :

Résultat :

Si vous avez besoin de quelque chose de plus compliqué, comme dessiner un maillage de main avec un nuanceur personnalisé, vous devez obtenir les maillages en tant que géométrie suivie.

Rayons émanant de la main

L’obtention d’une pose manuelle fonctionne pour des interactions étroites, comme saisir des objets ou appuyer sur des boutons. Toutefois, vous devez parfois utiliser des hologrammes éloignés de vos utilisateurs. Cela peut être effectué avec des rayons de main, qui peuvent être utilisés comme pointage des appareils dans C++ et Blueprints. Vous pouvez dessiner un rayon de votre main jusqu’à un point lointain et, avec une aide du traçage des rayons Unreal, sélectionnez un hologramme qui serait autrement hors de portée.

Important

Étant donné que tous les résultats de la fonction changent chaque image, ils sont tous appelants. Pour plus d’informations sur les fonctions pures et impurables ou appelantes, consultez le guid utilisateur blueprint sur les fonctions.

4.26

Pour obtenir les données des rayons de main, vous devez utiliser la fonction Obtenir les données du contrôleur de mouvement de la section précédente. La structure retournée contient deux paramètres que vous pouvez utiliser pour créer un rayon de main : position de l’objectif et rotation de l’objectif. Ces paramètres forment un rayon dirigé par votre coude. Vous devez les prendre et trouver un hologramme pointé par.

Vous trouverez ci-dessous un exemple de détermination si un rayon de main atteint un widget et définit un résultat d’accès personnalisé :

4.25

Pour utiliser des rayons de main dans blueprints, recherchez l’une des actions sous Windows Mixed Reality HMD :

Pour y accéder en C++, incluez-les WindowsMixedRealityFunctionLibrary.h en haut de votre fichier de code appelant.

Enum

Vous avez également accès aux cas d’entrée sous EHMDInputControllerButtons, qui peuvent être utilisés dans blueprints :

Pour accéder en C++, utilisez la EHMDInputControllerButtons classe enum :

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

Voici une répartition des deux cas d’énumération applicables :

• Select - Événement Select déclenché par l’utilisateur.
  • Déclenché dans HoloLens 2 par appui aérien, regardez et validez, ou en disant « Sélectionner » avec entrée vocale activée.
• Grasp - Événement Grasp déclenché par l’utilisateur.
  • Déclenché dans HoloLens 2 en fermant les doigts de l’utilisateur sur un hologramme.

Vous pouvez accéder à l’état de suivi de votre maillage de main en C++ via l’énumération EHMDTrackingStatus indiquée ci-dessous :

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

Voici une répartition des deux cas d’énumération applicables :

• NotTracked : la main n’est pas visible
• Suivi : la main est entièrement suivie

Struct

Le struct PointerPoseInfo peut vous fournir des informations sur les données de la main suivantes :

• Origine : origine de la main
• Direction : direction de la main
• Vers le haut : vecteur vers le haut de la main
• Orientation – quaternion d’orientation
• État de suivi : état de suivi actuel

Vous pouvez accéder au struct PointerPoseInfo via Blueprints, comme indiqué ci-dessous :

Ou avec C++ :

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

Functions

Toutes les fonctions répertoriées ci-dessous peuvent être appelées sur chaque image, ce qui permet une surveillance continue.

1. Obtenir des informations sur la pose de pointeur retourne des informations complètes sur la direction des rayons de main dans le cadre actuel.

Plan:

C++ :

static FPointerPoseInfo UWindowsMixedRealityFunctionLibrary::GetPointerPoseInfo(EControllerHand hand);

2. Est saisi renvoie true si la main est saisie dans le cadre actuel.

Plan:

C++ :

static bool UWindowsMixedRealityFunctionLibrary::IsGrasped(EControllerHand hand);

3. La fonction Sélectionner enfoncée renvoie la valeur true si l’utilisateur a déclenché Sélectionner dans le cadre actuel.

Plan:

C++ :

static bool UWindowsMixedRealityFunctionLibrary::IsSelectPressed(EControllerHand hand);

4. Le bouton Clicked renvoie la valeur true si l’événement ou le bouton est déclenché dans le cadre actuel.

Plan:

C++ :

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

5. Obtenir l’état du suivi du contrôleur retourne l’état de suivi dans l’image actuelle.

Plan:

C++ :

static EHMDTrackingStatus UWindowsMixedRealityFunctionLibrary::GetControllerTrackingStatus(EControllerHand hand);

Mouvements

HoloLens 2 effectue le suivi des mouvements spatiaux, ce qui signifie que vous pouvez capturer ces mouvements en tant qu’entrée. Le suivi des mouvements est basé sur un modèle d’abonnement. Vous devez utiliser la fonction « Configurer les mouvements » pour indiquer à l’appareil les mouvements que vous souhaitez suivre. Vous trouverez plus d’informations sur les mouvements dans le document d’utilisation de base HoloLens 2.

4.26

Windows Mixed Reality

Ensuite, vous devez ajouter du code pour vous abonner aux événements suivants :

OpenXR

Dans OpenXR, les événements de mouvement sont suivis via le pipeline d’entrée. À l’aide de l’interaction manuelle, l’appareil peut reconnaître automatiquement les mouvements d’appui et de conservation, mais pas les autres. Ils sont nommés comme mappages OpenXRMsftHandInteraction Select et Grip. Vous n’avez pas besoin d’activer l’abonnement. Vous devez déclarer les événements dans Project Paramètres/Engine/Input, comme suit :

4.25

Vous trouverez la fonction Blueprint dans windows Mixed Reality Spatial Input et la fonction C++ en ajoutant WindowsMixedRealitySpatialInputFunctionLibrary.h votre fichier de code appelant.

Enum

Plan:

C++ :

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

Fonction

Vous pouvez activer et désactiver la capture de mouvements avec la CaptureGestures fonction. Lorsqu’un mouvement activé déclenche des événements d’entrée, la fonction retourne true si la capture de mouvement a réussi et false s’il y a une erreur.

Plan:

C++ :

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

Voici les événements clés que vous trouverez dans Blueprints et 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);

Point de contrôle de développement suivant

Si vous suivez le parcours de développement Unreal que nous avons mis en place, vous êtes en train d’explorer les modules de base du MRTK. À partir d’ici, vous pouvez passer au composant suivant :

Ancres spatiales locales

Ou accéder aux API et fonctionnalités de la plateforme Mixed Reality :

Caméra HoloLens

Vous pouvez revenir aux points de contrôle de développement Unreal à tout moment.