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. Des données sur la position et la rotation de chaque doigt, de la paume entière et des mouvements de la 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 à l’ensemble des plateformes et appareils XR. Les fonctionnalités sont les mêmes 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 en tant qu’entrée, qui sont accessibles à la fois dans Blueprints et C++. L’API Unreal envoie les données sous forme de système de coordonnées, avec des graduations synchronisées avec le moteur Unreal.

4.26

La hiérarchie est décrite par EHandKeypoint enum :

Vous pouvez obtenir toutes ces données 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 . Voici 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’il s’agit d’une main. Sinon, vous risquez d’obtenir un comportement non défini dans l’accès aux positions, aux rotations et aux tableaux de rayons.

4.25

L’énumération EWMRHandKeypoint décrit la hiérarchie osseuse de la main. Vous pouvez trouver 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 de chaque cas d’énumération dans windows.Perception.Personnes. Table HandJointKind.

Prise en charge du suivi de la main

Vous pouvez utiliser le suivi des mains dans Blueprints en ajoutant Prend en charge le suivi des mains à partir de > Windows Mixed Reality :

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

C++ :

Incluez WindowsMixedRealityHandTrackingFunctionLibrary.h.

static bool UWindowsMixedRealityHandTrackingFunctionLibrary::SupportsHandTracking()

Obtention du suivi de la main

Vous pouvez utiliser GetHandJointTransform pour retourner des données spatiales à partir 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 : peut être la main gauche ou droite des utilisateurs.
• Touche : 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 la fin de distal.
• **Radius : rayon de la base de l’os.
• **Valeur de retour : true si l’os est suivi dans ce cadre, false si l’os n’est pas suivi.

Hand Live Link Animation

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

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

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

Une fois que vous avez activé la source et ouvert une ressource d’animation, développez la section Animation sous l’onglet Aperçu de la scène pour afficher des options supplémentaires.

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

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

Maille à la main

Important

Le maillage des mains nécessite OpenXR.

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

Maillage de main en tant que géométrie suivie

Important

Pour obtenir des maillages de main en tant que géométrie suivie dans OpenXR, vous devez appeler Set Use Hand Mesh with Enabled Tracking Geometry.

Pour activer ce mode, vous devez appeler Set Use Hand Mesh with Enabled Tracking Geometry :

Notes

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 Settings -> World Mapping et case activée Generate Mesh Data from Tracked Geometry.

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

1. Utiliser des données de maillage pour l’occlusion
2. Générer une collision pour les données de maillage
3. Générer un maillage de navigation pour les données de maillage
4. Rendu des données de maillage dans 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 maillage de main par défaut. Vous pouvez les modifier à tout moment dans blueprints ou code pour n’importe quel maillage.

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

Utilisez EEARObjectClassification pour 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 de 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 via :UARTrackedGeometry::GetUnderlyingMesh

UMRMeshComponent* UARTrackedGeometry::GetUnderlyingMesh()

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

Pour utiliser des maillages de 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. Remplacez lors de l’ajout/de la mise à jour/de la suppression d’une géométrie suivie par les nœuds suivants dans votre event Graph :

Visualisation du maillage de main dans OpenXR

La méthode recommandée pour visualiser le maillage des mains 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 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 sous forme de géométrie suivie.

Rayon émanant de la main

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

Important

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

4.26

Pour obtenir les données des rayons de la 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 la main : La position de l’objectif et la rotation de l’objectif. Ces paramètres forment un rayon dirigé par votre coude. Vous devez les prendre et trouver un hologramme pointé par.

Voici un exemple qui montre comment déterminer si un rayon de main atteint un widget et définir 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 WindowsMixedRealityFunctionLibrary.h en haut de votre fichier de code appelant.

Énumération

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

Pour l’accès en C++, utilisez la EHMDInputControllerButtons classe enum :

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

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

• Sélectionnez - Événement de sélection déclenché par l’utilisateur.
  • Déclenchée dans HoloLens 2 par appui aérien, le regard et la validation, ou en disant « Sélectionner » avec l’entrée vocale activée.
• Grasp : événement Grasp déclenché par l’utilisateur.
  • Déclenchée dans HoloLens 2 en fermant les doigts de l’utilisateur sur un hologramme.

Vous pouvez accéder à la status de suivi de votre maillage de main en C++ via l’énumération EHMDTrackingStatus illustré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

Structure

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
• Haut – haut vecteur de la main
• Orientation – quaternion d’orientation
• État du suivi : status 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;
};

Fonctions

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

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

Plan:

C++ :

static FPointerPoseInfo UWindowsMixedRealityFunctionLibrary::GetPointerPoseInfo(EControllerHand hand);

2. Is Grasped renvoie true si la main est saisie dans le cadre actuel.

Plan:

C++ :

static bool UWindowsMixedRealityFunctionLibrary::IsGrasped(EControllerHand hand);

3. La valeur 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 l’image actuelle.

Plan:

C++ :

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

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

Plan:

C++ :

static EHMDTrackingStatus UWindowsMixedRealityFunctionLibrary::GetControllerTrackingStatus(EControllerHand hand);

Mouvements

Le 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. Pour plus d’informations sur les mouvements, consultez le HoloLens 2 document Utilisation de base.

4.26

Windows Mixed Reality

Vous devez ensuite 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 maintien, mais pas les autres. Ils sont nommés mappages OpenXRMsftHandInteraction Select et Grip. Vous n’avez pas besoin d’activer l’abonnement. Vous devez déclarer les événements dans Paramètres du projet/Moteur/Entrée, comme ceci :

4.25

Vous pouvez trouver la fonction Blueprint dans sous Windows Mixed Reality Entrée spatiale et la fonction C++ en ajoutant WindowsMixedRealitySpatialInputFunctionLibrary.h dans votre fichier de code appelant.

Énumération

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 pouvez trouver 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 de là, vous pouvez passer au module 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.