Sélection de la cible prise en charge par les yeux — MRTK2

Cette page présente différentes options pour accéder aux données du regard et aux événements spécifiques du regard pour sélectionner des cibles dans MRTK. Le suivi oculaire permet des sélections de cibles rapides et faciles à l’aide d’une combinaison d’informations sur ce qu’un utilisateur regarde avec des entrées supplémentaires telles que le suivi de la main et les commandes vocales :

• Regardez & dites « Sélectionner » (commande vocale par défaut)
• Look & Say « Explode » ou « Pop » (commandes vocales personnalisées)
• Regarder & bouton Bluetooth
• Regardez & Pinch (c’est-à-dire, tenez votre main devant vous et mettez le pouce et l’index ensemble)
  • Veuillez noter que pour que cela fonctionne, les rayons de la main doivent être désactivés

Pour sélectionner du contenu holographique à l’aide du regard, il existe plusieurs options :

1. Utilisez le pointeur de focus principal :

Cela peut être compris comme votre curseur hiérarchisé. Par défaut, si les mains sont en vue, il s’agit de rayons de la main. Si aucune main n’est en vue, le pointeur prioritaire est la tête ou le regard. Par conséquent, veuillez noter que, en fonction de la tête de conception ou du regard actuel, le regard est supprimé en tant qu’entrée de curseur si des rayons de main sont utilisés.

Par exemple :

Un utilisateur souhaite sélectionner un bouton holographique distant. En tant que développeur, vous souhaitez fournir une solution flexible qui permet à l’utilisateur d’effectuer ces tâches dans différentes conditions :

• Monter jusqu’au bouton et le piquer
• Regardez-le à distance et dites « sélectionner »
• Cibler le bouton à l’aide d’un rayon de main et effectuer un pincement Dans ce cas, la solution la plus flexible consiste à utiliser le gestionnaire de focus principal, car il vous avertit chaque fois que le pointeur de focus principal actuellement hiérarchisé déclenche un événement. Notez que si les rayons de la main sont activés, le pointeur de focus de la tête ou du regard est désactivé dès que les mains entrent en vue.

2. Utilisez à la fois le focus oculaire et les rayons de la main en même temps :

Il peut arriver que vous souhaitiez être plus précis sur le type de pointeur de focus pouvant déclencher certains événements et permettre l’utilisation simultanée de plusieurs techniques d’interaction de loin.

Par exemple : dans votre application, un utilisateur peut utiliser des rayons de la main lointaine pour manipuler une configuration mécanique holographique, par exemple, saisir et maintenir certaines parties distantes du moteur holographique et les maintenir en place. Ce faisant, l’utilisateur doit suivre un certain nombre d’instructions et enregistrer sa progression en marquant certaines zones case activée. Si l’utilisateur n’a pas les mains occupées, il serait instinctif de simplement toucher la boîte de case activée ou de la sélectionner à l’aide d’un rayon de main. Toutefois, si l’utilisateur a les mains occupées, comme dans notre cas en tenant certaines parties du moteur holographique en place, vous souhaitez permettre à l’utilisateur de faire défiler les instructions en toute transparence à l’aide de son regard et de simplement regarder une boîte de case activée et de dire « case activée ! ».

Pour cela, vous devez utiliser le script EyeTrackingTarget spécifique à l’œil qui est indépendant des gestionnaires de focus MRTK de base et qui sera abordé plus en détail ci-dessous.

1. Utiliser des gestionnaires de pointeurs et de focus génériques

Si le suivi oculaire est correctement configuré (voir Configuration MRTK de base pour utiliser le suivi oculaire), le fait de permettre aux utilisateurs de sélectionner des hologrammes à l’aide de leurs yeux est le même que pour toute autre entrée de focus (par exemple, le regard de la tête ou le rayon de la main). Cela offre le grand avantage d’un moyen flexible d’interagir avec vos hologrammes en définissant le type de focus principal dans votre profil de pointeur d’entrée MRTK en fonction des besoins de votre utilisateur, tout en laissant votre code intact. Cela permet de basculer entre la tête ou le regard sans modifier une ligne de code ou de remplacer les rayons de la main par le ciblage oculaire pour les interactions lointaines.

Se concentrer sur un hologramme

Pour détecter quand un hologramme est ciblé, utilisez l’interface « IMixedRealityFocusHandler » qui vous fournit deux membres d’interface : OnFocusEnter et OnFocusExit.

Voici un exemple simple de ColorTap.cs pour modifier la couleur d’un hologramme lors de l’analyse.

public class ColorTap : MonoBehaviour, IMixedRealityFocusHandler
{
    void IMixedRealityFocusHandler.OnFocusEnter(FocusEventData eventData)
    {
        material.color = color_OnHover;
    }

    void IMixedRealityFocusHandler.OnFocusExit(FocusEventData eventData)
    {
        material.color = color_IdleState;
    }
    ...
}

Sélection d’un hologramme ciblé

Pour sélectionner un hologramme ciblé, utilisez PointerHandler pour écouter les événements d’entrée afin de confirmer une sélection. Par exemple, l’ajout de IMixedRealityPointerHandler les fait réagir à une entrée de pointeur simple. L’interface IMixedRealityPointerHandler nécessite l’implémentation des trois membres d’interface suivants : OnPointerUp, OnPointerDown et OnPointerClicked.

Dans l’exemple ci-dessous, nous modifions la couleur d’un hologramme en le regardant et en le pinçant ou en disant « sélectionner ». L’action requise pour déclencher l’événement est définie en eventData.MixedRealityInputAction == selectAction définissant le type de selectAction dans l’éditeur Unity . Par défaut, il s’agit de l’action « Sélectionner ». Les types de MixedRealityInputActions disponibles peuvent être configurés dans le profil MRTK via le profil de configuration MRTK ->Input ->Input Actions.

public class ColorTap : MonoBehaviour, IMixedRealityFocusHandler, IMixedRealityPointerHandler
{
    // Allow for editing the type of select action in the Unity Editor.
    [SerializeField]
    private MixedRealityInputAction selectAction = MixedRealityInputAction.None;
    ...

    void IMixedRealityPointerHandler.OnPointerUp(MixedRealityPointerEventData eventData)
    {
        if (eventData.MixedRealityInputAction == selectAction)
        {
            material.color = color_OnHover;
        }
    }

    void IMixedRealityPointerHandler.OnPointerDown(MixedRealityPointerEventData eventData)
    {
        if (eventData.MixedRealityInputAction == selectAction)
        {
            material.color = color_OnSelect;
        }
    }

    void IMixedRealityPointerHandler.OnPointerClicked(MixedRealityPointerEventData eventData) { }
}

BaseEyeFocusHandler spécifique aux yeux

Étant donné que le regard peut être très différent des autres entrées de pointeur, vous pouvez veiller à ne réagir à l’entrée de focus que s’il s’agit du pointeur d’œil et qu’il s’agit actuellement du pointeur d’entrée principal. À cet effet, vous utiliseriez le BaseEyeFocusHandler qui est spécifique au suivi oculaire et qui dérive du BaseFocusHandler. Comme mentionné précédemment, il se déclenche uniquement si le ciblage du regard est actuellement l’entrée principale du pointeur (c’est-à-dire qu’aucun rayon de main n’est actif). Pour plus d’informations, consultez Comment prendre en charge les mouvements du regard et de la main.

Voici un exemple de EyeTrackingDemo-03-Navigation (Assets/MRTK/Examples/Demos/EyeTracking/Scenes). Dans cette démonstration, deux hologrammes 3D s’activent en fonction de la partie de l’objet examinée : si l’utilisateur regarde le côté gauche de l’hologramme, cette partie se déplace lentement vers l’avant de l’utilisateur. Si le côté droit est regardé, cette partie se déplace lentement vers l’avant. Il s’agit d’un comportement que vous ne voudrez peut-être pas avoir actif en tout temps et aussi quelque chose que vous ne voudrez peut-être pas déclencher accidentellement par un rayon de main ou un regard de tête. Avec le OnLookAtRotateByEyeGaze attaché, un GameObject pivote pendant qu’il est examiné.

public class OnLookAtRotateByEyeGaze : BaseEyeFocusHandler
{
    ...

    protected override void OnEyeFocusStay()
    {
        // Update target rotation
        RotateHitTarget();
    }

    ...

    ///
    /// This function computes the rotation of the target to move the currently
    /// looked at aspect slowly to the front.
    ///
    private void RotateHitTarget()
    {
        // Example for querying the hit position of the eye gaze ray using EyeGazeProvider
        Vector3 TargetToHit = (this.gameObject.transform.position - InputSystem.EyeGazeProvider.HitPosition).normalized;

        ...
    }
}

Consultez la documentation de l’API pour obtenir la liste complète des événements disponibles du BaseEyeFocusHandler:

• OnEyeFocusStart : Déclenchée une fois que le rayon du regard commence à croiser avec le collider de cette cible.
• OnEyeFocusStay : Déclenchée pendant que le rayon du regard se croise avec le collider de cette cible.
• OnEyeFocusStop : Déclenchée une fois que le rayon du regard cesse de croiser le collider de cette cible.
• OnEyeFocusDwell : Déclenchée une fois que le rayon du regard a croisé le collider de cette cible pendant un laps de temps spécifié.

2. EyeTrackingTarget indépendant spécifique à l’œil

Enfin, nous vous fournissons une solution qui vous permet de traiter les entrées basées sur les yeux complètement indépendantes des autres pointeurs de focus via le EyeTrackingTarget script.

Cela présente trois avantages :

• Vous pouvez vous assurer que l’hologramme réagit uniquement au regard de l’utilisateur.
• Ceci est indépendant de l’entrée principale actuellement active. Par conséquent, vous pouvez traiter plusieurs entrées à la fois, par exemple, en combinant un ciblage oculaire rapide avec des mouvements de la main.
• Plusieurs événements Unity ont déjà été configurés pour faciliter la gestion et la réutilisation des comportements existants à partir de l’éditeur Unity ou via du code.

Il existe également quelques inconvénients :

• Plus d’efforts pour gérer des entrées distinctes individuellement.
• Aucune dégradation élégante : il prend uniquement en charge le ciblage oculaire. Si le suivi oculaire ne fonctionne pas, vous avez besoin d’une solution de secours supplémentaire.

À l’instar de BaseFocusHandler, EyeTrackingTarget est prêt avec plusieurs événements Unity spécifiques aux yeux que vous pouvez facilement écouter via l’éditeur Unity (voir l’exemple ci-dessous) ou en utilisant AddListener() dans le code :

• OnLookAtStart()
• WhileLookingAtTarget()
• OnLookAway()
• OnDwell()
• OnSelected()

Dans ce qui suit, nous vous guiderons à travers quelques exemples d’utilisation d’EyeTrackingTarget.

Exemple n°1 : notifications intelligentes prises en charge par les yeux

Dans EyeTrackingDemo-02-TargetSelection (Assets/MRTK/Examples/Demos/EyeTracking/Scenes), vous pouvez trouver un exemple de « notifications intelligentes attentives » qui réagissent à votre regard. Il s’agit de zones de texte 3D qui peuvent être placées dans la scène et qui s’agrandiront et se tourneront facilement vers l’utilisateur lorsqu’ils sont examinés pour faciliter la lisibilité. Pendant que l’utilisateur lit la notification, les informations continuent d’être affichées nettes et claires. Après l’avoir lu et regardé loin de la notification, la notification est automatiquement ignorée et s’efface. Pour ce faire, il existe quelques scripts de comportement génériques qui ne sont pas spécifiques au suivi oculaire, par exemple :

• FaceUser
• ChangeSize
• BlendOut

L’avantage de cette approche est que les mêmes scripts peuvent être réutilisés par différents événements. Par exemple, un hologramme peut commencer à faire face à l’utilisateur en fonction d’une commande vocale ou après avoir appuyé sur un bouton virtuel. Pour déclencher ces événements, vous pouvez simplement référencer les méthodes qui doivent être exécutées dans le EyeTrackingTarget script attaché à votre GameObject.

Pour l’exemple des « notifications intelligentes attentives », les opérations suivantes se produisent :

• OnLookAtStart() : la notification commence à...

  • FaceUser. Engage : ... tourner vers l’utilisateur.
  • ChangeSize. Engage : ... augmentation de la taille (jusqu’à une échelle maximale spécifiée).
  • BlendOut. Engage : ... commence à se fondre dans plus (après avoir été à un état d’inactivité plus subtil).

• OnDwell() : informe le script BlendOut que la notification a été suffisamment examinée.

• OnLookAway() : la notification commence à...

  • FaceUser.Désengagement : ... revenir à son orientation d’origine.
  • ChangeSize.Désengagement : ... revenir à sa taille d’origine.
  • BlendOut.Désengagement : ... commence à fusionner : si OnDwell() a été déclenché, fusionnez complètement et détruisez, sinon revenez à son état inactif.

Considérations relatives à la conception : La clé d’une expérience agréable ici est d’ajuster soigneusement la vitesse de l’un de ces comportements afin d’éviter de causer de l’inconfort en réagissant au regard de l’utilisateur trop rapidement tout le temps. Sinon, cela peut rapidement sembler extrêmement écrasant.

Exemple n°2 : La gemme holographique pivote lentement en la regardant

À l’instar de l’exemple n° 1, nous pouvons facilement créer un retour de pointage pour nos gemmes holographiques dans EyeTrackingDemo-02-TargetSelection la scène (Assets/MRTK/Examples/Demos/EyeTracking/Scenes) qui tourne lentement dans une direction constante et à une vitesse constante (contrairement à l’exemple de rotation ci-dessus) lors de l’examen. Il vous suffit de déclencher la rotation de la gemme holographique à partir de l’événement WhileLookingAtTarget() de EyeTrackingTarget. Voici quelques détails supplémentaires :

1. Créez un script générique qui inclut une fonction publique pour faire pivoter le GameObject auquel elle est attachée. Voici un exemple de RotateWithConstSpeedDir.cs où nous pouvons ajuster la direction et la vitesse de rotation à partir de l’éditeur Unity.

   using UnityEngine;
   
   namespace Microsoft.MixedReality.Toolkit.Examples.Demos.EyeTracking
   {
       /// <summary>
       /// The associated GameObject will rotate when RotateTarget() is called based on a given direction and speed.
       /// </summary>
       public class RotateWithConstSpeedDir : MonoBehaviour
       {
           [Tooltip("Euler angles by which the object should be rotated by.")]
           [SerializeField]
           private Vector3 RotateByEulerAngles = Vector3.zero;
   
           [Tooltip("Rotation speed factor.")]
           [SerializeField]
           private float speed = 1f;
   
           /// <summary>
           /// Rotate game object based on specified rotation speed and Euler angles.
           /// </summary>
           public void RotateTarget()
           {
               transform.eulerAngles = transform.eulerAngles + RotateByEulerAngles * speed;
           }
       }
   }
   

2. Ajoutez le EyeTrackingTarget script à votre GameObject cible et référencez la fonction RotateTarget() dans le déclencheur UnityEvent, comme illustré dans la capture d’écran ci-dessous :

   

Exemple n°3 : Afficher ces gemmes, alias sélection cible prise en charge par le regard modal

Dans l’exemple précédent, nous avons montré à quel point il est facile de détecter si une cible est examinée et comment déclencher une réaction à celle-ci. Ensuite, faisons exploser les gemmes à l’aide de l’événement OnSelected() de .EyeTrackingTarget La partie intéressante est la façon dont la sélection est déclenchée. permet EyeTrackingTarget d’attribuer rapidement différentes façons d’appeler une sélection :

• Mouvement de pincement : la définition de « Sélectionner l’action » sur « Sélectionner » utilise le mouvement de la main par défaut pour déclencher la sélection. Cela signifie que l’utilisateur peut simplement lever la main et pincer le pouce et l’index ensemble pour confirmer la sélection.

• Dites « Sélectionner » : utilisez la commande vocale par défaut « Select » pour sélectionner un hologramme.

• Dites « Explode » ou « Pop » : pour utiliser des commandes vocales personnalisées, vous devez suivre deux étapes :

  1. Configurer une action personnalisée telle que « DestroyTarget »

     • Accédez à MRTK -> Entrée -> Actions d’entrée
     • Cliquez sur « Ajouter une nouvelle action »

  2. Configurer les commandes vocales qui déclenchent cette action, telles que « Exploser » ou « Pop »

     • Accédez à MRTK -> Entrée -> Speech
     • Cliquez sur « Ajouter une nouvelle commande vocale »
       • Associer l’action que vous venez de créer
       • Affecter un code clé pour permettre le déclenchement de l’action via un appui sur un bouton

Lorsqu’une gemme est sélectionnée, elle explose, faisant un son et disparaît. Cela est géré par le HitBehaviorDestroyOnSelect script. Vous disposez de deux options :

• Dans l’éditeur Unity : Vous pouvez simplement lier le script attaché à chacun de nos modèles gemmes à l’événement Unity OnSelected() dans l’éditeur Unity.
• Dans le code : Si vous ne souhaitez pas glisser-déplacer des GameObjects, vous pouvez simplement ajouter un écouteur d’événements directement à votre script.
  Voici un exemple de la façon dont nous l’avons fait dans le HitBehaviorDestroyOnSelect script :

/// <summary>
/// Destroys the game object when selected and optionally plays a sound or animation when destroyed.
/// </summary>
[RequireComponent(typeof(EyeTrackingTarget))] // This helps to ensure that the EyeTrackingTarget is attached
public class HitBehaviorDestroyOnSelect : MonoBehaviour
{
    ...
    private EyeTrackingTarget myEyeTrackingTarget = null;

    private void Start()
    {
        myEyeTrackingTarget = this.GetComponent<EyeTrackingTarget>();

        if (myEyeTrackingTarget != null)
        {
            myEyeTrackingTarget.OnSelected.AddListener(TargetSelected);
        }
    }

    ...

    ///
    /// This is called once the EyeTrackingTarget detected a selection.
    ///
    public void TargetSelected()
    {
        // Play some animation
        // Play some audio effect
        // Handle destroying the target appropriately
    }
}

Exemple n°4 : utiliser les rayons de la main et l’entrée du regard

Les rayons de la main sont prioritaires sur le ciblage de la tête et du regard. Cela signifie que, si les rayons de la main sont activés, au moment où les mains entrent en vue, le rayon de la main agit comme pointeur principal. Toutefois, il peut y avoir des situations dans lesquelles vous souhaitez utiliser des rayons de la main tout en détectant si un utilisateur examine un certain hologramme. Facile! Pour l’essentiel, vous avez besoin de deux étapes :

1. Activer le rayon de main : pour activer le rayon de main, accédez à Mixed Reality Kit de ressources -> Entrée -> Pointeurs. Dans eyeTrackingDemo-00-RootScene où Mixed Reality Toolkit est configuré une fois pour toutes les scènes de démonstration de suivi oculaire, vous devez voir eyeTrackingDemoPointerProfile. Vous pouvez créer un profil d’entrée à partir de zéro ou adapter le suivi oculaire actuel :

• À partir de zéro : Sous l’onglet Pointeurs , sélectionnez DefaultMixedRealityInputPointerProfile dans le menu contextuel. Il s’agit du profil de pointeur par défaut pour lequel le rayon de main est déjà activé ! Pour modifier le curseur par défaut (un point blanc opaque), clonez simplement le profil et créez votre propre profil de pointeur personnalisé. Remplacez ensuite DefaultCursor parEyeGazeCursor sous Le prefab du curseur du regard.
• En fonction de l’eyeTrackingDemoPointerProfile existant : double-cliquez sur eyeTrackingDemoPointerProfile et ajoutez l’entrée suivante sous Options du pointeur :
  • Type de contrôleur : 'Main articulée', 'Windows Mixed Reality'
  • Les mains : Tout
  • Prefab pointeur : DefaultControllerPointer

2. Détecter qu’un hologramme est examiné : utilisez le EyeTrackingTarget script pour détecter qu’un hologramme est examiné comme décrit ci-dessus. Vous pouvez également consulter l’exemple FollowEyeGaze de script pour vous inspirer, car il montre un hologramme suivant votre regard (par exemple, un curseur) que les rayons de la main soient activés ou non.

Maintenant, lorsque vous démarrez les scènes de démonstration de suivi oculaire, vous devriez voir un rayon provenant de vos mains. Par exemple, dans la démonstration de sélection de la cible de suivi oculaire, le cercle semi-transparent suit toujours votre regard et les gemmes répondent à leur regard ou non, tandis que les boutons de menu de la scène supérieure utilisent le pointeur d’entrée principal (vos mains) à la place.

Retour à « Eye tracking in the MixedRealityToolkit »