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

MRTK

Cette page traite des différentes options d’accès aux données de regard et d’événements spécifiques au regard des yeux pour sélectionner des cibles dans MRTK. Le suivi oculaire permet des sélections de cibles rapides et sans effort à l’aide d’une combinaison d’informations sur ce qu’un utilisateur examine avec des entrées supplémentaires telles que le suivi des mains et les commandes vocales :

  • Look & Say « Select » (commande vocale par défaut)
  • Look & Say « Exploser » ou « Pop » (commandes vocales personnalisées)
  • Rechercher & le bouton Bluetooth
  • Regardez & pincé (c’est-à-dire tenir votre main devant vous et ramenez votre pouce et votre doigt d’index ensemble)

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, cela serait des rayons de main. Si aucune main n’est en vue, le pointeur hiérarchisé serait le regard ou la tête. Par conséquent, notez qu’en fonction du regard ou de la tête de conception actuelle est supprimé en tant qu’entrée de curseur si les 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 faire passer
  • Regardez-le à partir d’une distance et dites « sélectionner »
  • Ciblez le bouton à l’aide d’un rayon de main et effectuez une pincement Dans ce cas, la solution la plus flexible consiste à utiliser le gestionnaire de focus principal car il vous avertira chaque fois que le pointeur de focus principal actuellement hiérarchisé déclenche un événement. Notez que si les rayons de main sont activés, le pointeur de focus de la tête ou des yeux est désactivé dès que les mains entrent en vue.

Important

Notez que si les rayons de main sont activés, le pointeur de focus de la tête ou des yeux est désactivé dès que les mains entrent en vue. Si vous souhaitez prendre en charge une interaction « look and pinch », vous devez désactiver le rayon de main. Dans nos exemples de scènes de suivi oculaire, nous avons désactivé le rayon de main pour permettre de présenter des interactions plus riches à l’aide d’yeux + mouvements de main - voir par exemple positionnement pris en charge par les yeux.

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

Il peut y avoir des instances où vous souhaitez être plus spécifique quel type de pointeur de focus peut déclencher certains événements et autoriser simultanément à utiliser plusieurs techniques d’interaction de loin.

Par exemple : Dans votre application, un utilisateur peut utiliser des rayons de loin pour manipuler une configuration mécanique holographique , par exemple, saisir et contenir des pièces de moteur holographique distantes et les tenir en place. En procédant ainsi, l’utilisateur doit passer par un certain nombre d’instructions et enregistrer sa progression en désactivant certaines cases à cocher. Si l’utilisateur n’a pas ses mains occupées, il serait instinctif de simplement toucher la case à cocher ou de le sélectionner à l’aide d’un rayon de main. Toutefois, si l’utilisateur a ses mains occupées, comme dans notre cas en tenant des parties du moteur holographique en place, vous souhaitez permettre à l’utilisateur de faire défiler en toute transparence les instructions à l’aide de son regard et de simplement regarder une case à cocher et de dire « cochez! ».

Pour ce faire, vous devez utiliser un script EyeTrackingTarget spécifique à l’œil qui est indépendant des principaux gestionnaires de focus MRTK et qui sera abordé plus loin ci-dessous.

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

Si le suivi oculaire est correctement configuré (voir Configuration MRTK de base pour utiliser le suivi oculaire), permettre aux utilisateurs de sélectionner des hologrammes à l’aide de leurs yeux est identique à toute autre entrée de focus (par exemple, le regard de la tête ou le rayon de main). Cela offre l’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 inchangé. Cela permet de basculer entre la tête ou le regard sans modifier une ligne de code ou remplacer les rayons de main par le ciblage oculaire pour les interactions de loin.

Mise en place d’un hologramme

Pour détecter quand un hologramme est concentré, 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 pour confirmer une sélection. Par exemple, l’ajout de IMixedRealityPointerHandler les fera 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 l’examinant et en le appuyant ou en disant « sélectionner ». L’action requise pour déclencher l’événement est définie par eventData.MixedRealityInputAction == selectAction le moyen duquel nous pouvons définir le type de l’éditeur Unity , par défaut, il s’agit de selectAction 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.

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 vous assurer de ne réagir qu’à l’entrée de focus s’il s’agit d’un regard oculaire et qu’il s’agit actuellement du pointeur d’entrée principal. À cet effet, vous allez utiliser celui BaseEyeFocusHandler qui est spécifique au suivi oculaire et qui dérive du BaseFocusHandler. Comme mentionné précédemment, il ne déclenche que si le ciblage du regard est actuellement l’entrée du pointeur principal (c’est-à-dire qu’aucun rayon de main n’est actif). Pour plus d’informations, consultez Comment prendre en charge le regard et les mouvements de main.

Voici un exemple de EyeTrackingDemo-03-Navigation (Assets/MRTK/Examples/Demos/EyeTracking/Scenes). Dans cette démonstration, il existe deux hologrammes 3D qui tournent selon la partie de l’objet qui est examinée : si l’utilisateur examine le côté gauche de l’hologramme, cette partie se déplace lentement vers l’avant face de l’utilisateur. Si le côté droit est examiné, cette partie se déplace lentement vers l’avant. Il s’agit d’un comportement que vous ne souhaiterez peut-être pas avoir actif à tout moment et aussi quelque chose que vous ne souhaiterez peut-être pas déclencher accidentellement par un rayon de main ou un regard de tête. Avec l’attachement OnLookAtRotateByEyeGaze , un GameObject pivotera tout en étant regardé.

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é une fois que le rayon de regard commence à se croiser avec le collisionneur de cette cible.
  • OnEyeFocusStay : Déclenché pendant que le rayon de regard se croise avec le collisionneur de cette cible.
  • OnEyeFocusStop : Déclenché une fois que le rayon de regard cesse de se croiser avec le collisionneur de cette cible.
  • OnEyeFocusDwell : Déclenché une fois le rayon de regard croisé avec le collisionneur de cette cible pendant une durée spécifiée.

2. Regard indépendant spécifique à EyeTrackingTarget

Enfin, nous vous fournissons une solution qui vous permet de traiter l’entrée basée sur les yeux complètement indépendante 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.
  • Cela est indépendant de l’entrée primaire actuellement active. Par conséquent, vous pouvez traiter plusieurs entrées à la fois : par exemple, combiner le ciblage rapide des yeux avec les mouvements de main.
  • Plusieurs événements Unity ont déjà été configurés pour le rendre rapide et pratique pour gérer et réutiliser les comportements existants à partir de l’Éditeur Unity ou via du code.

Il existe également quelques inconvénients :

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

Comme pour BaseFocusHandler, eyeTrackingTarget est prêt avec plusieurs événements Unity spécifiques aux yeux que vous pouvez écouter de manière pratique via l’Éditeur Unity (voir l’exemple ci-dessous) ou à l’aide de AddListener() dans le code :

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

Dans ce qui suit, nous vous expliquons quelques exemples pour utiliser EyeTrackingTarget.

Exemple #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 attentives intelligentes » qui réagissent à votre regard oculaire. Il s’agit de zones de texte 3D qui peuvent être placées dans la scène et qui vont s’agrandir et se tourner vers l’utilisateur lorsqu’ils sont examinés pour faciliter la lisibilité. Bien que l’utilisateur lit la notification, les informations continuent d’être affichées nettes et claires. Après l’avoir lu et en regardant loin de la notification, la notification est automatiquement ignorée et est fondue. Pour ce faire, il existe quelques scripts de comportement génériques qui ne sont pas spécifiques au suivi oculaire du tout, tels que :

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 attentives intelligentes », les opérations suivantes se produisent :

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

    • FaceUser.Engage : ... tournez vers l’utilisateur.
    • ChangeSize.Engage : ... augmentation de la taille (jusqu’à une échelle maximale spécifiée).
    • BlendOut.Engage : ... commence à se mélanger en plus (après avoir été à un état d’inactivité plus subtil).
  • OnDwell(): informe le script BlendOut que la notification a été examinée suffisamment.

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

    • FaceUser.Désengage : ... revenez à son orientation d’origine.
    • ChangeSize.Désengagement : ... réduisez sa taille d’origine.
    • BlendOut.Désengagement : ... commence à se fusionner - Si OnDwell() a été déclenché, fusionnez complètement et détruit, sinon revenez à son état inactif.

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

Notification cible

Exemple #2 : la gemme holographique pivote lentement lors de son regard

Comme pour l’exemple #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 pivote lentement dans une direction constante et à une vitesse constante (contrairement à l’exemple de rotation ci-dessus) lors de l’examen. Tout ce dont vous avez besoin est de déclencher la rotation du gemme holographique à partir de l’événement WhileLookingAtTarget()d’EyeTrackingTarget(). Voici quelques informations supplémentaires :

  1. Créez un script générique qui inclut une fonction publique pour faire pivoter GameObject auquel il est attaché. Voici un exemple de RotateWithConstSpeedDir.cs où nous pouvons ajuster la direction de rotation et la vitesse 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 script à votre cible GameObject et référencez la EyeTrackingTarget fonction RotateTarget() dans le déclencheur UnityEvent, comme illustré dans la capture d’écran ci-dessous :

    Exemple EyeTrackingTarget

Exemple #3 : Pop ces gemmes aka multi-modal eye-gaze-supported target selection

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

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

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

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

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

      • Accéder à 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éder à MRTK -> Entrée -> Speech
      • Cliquez sur « Ajouter une nouvelle commande speech »
        • Associer l’action que vous venez de créer
        • Affecter un KeyCode pour autoriser le déclenchement de l’action par le biais d’un bouton

Exemples de commandes vocales EyeTrackingTarget

Quand un gemme est sélectionné, il va exploser, faire un son et disparaître. Cela est géré par le HitBehaviorDestroyOnSelect script. Deux options s'offrent à vous :

  • Dans l’éditeur Unity : Vous pouvez simplement lier le script attaché à chacun de nos modèles de gemme à l’événement OnSelected() Unity dans l’Éditeur Unity.
  • Dans le code : Si vous ne souhaitez pas faire glisser-déplacer GameObjects, vous pouvez également 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 #4 : Utiliser les rayons de main et l’entrée du regard ensemble

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

1. Activez 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 le EyeTrackingDemoPointerProfile. Vous pouvez créer un profil d’entrée à partir de zéro ou adapter le suivi oculaire actuel en un :

  • À 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 qui dispose déjà du rayon de main activé ! Pour modifier le curseur par défaut (point blanc opaque), clonez simplement le profil et créez votre propre profil de pointeur personnalisé. Remplacez ensuite DefaultCursor par EyeGazeCursor sous le préfab du curseur de regard.
  • En fonction de l’élément EyeTrackingDemoPointerProfile existant : double-cliquez sur eyeTrackingDemoPointerProfile et ajoutez l’entrée suivante sous Options de pointeur :
    • Type de contrôleur : 'Main articulée', 'Windows Mixed Reality'
    • Remise : Tout
    • Prefab du pointeur : DefaultControllerPointer

2. Détecter qu’un hologramme est examiné : utilisez le EyeTrackingTarget script pour permettre de détecter qu’un hologramme est examiné comme décrit ci-dessus. Vous pouvez également examiner l’exemple de FollowEyeGaze script d’inspiration, car cela montre un hologramme suivant votre regard oculaire (par exemple, un curseur) si les rayons de main sont activés ou non.

Maintenant, lorsque vous démarrez les scènes de démonstration de suivi des yeux, vous devriez voir un rayon provenant de vos mains. Par exemple, dans la démonstration de sélection cible de suivi des yeux, le cercle semi-transparent suit toujours votre regard et les gemmes répondent si elles sont examinées 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.


Revenez à « Suivi oculaire dans MixedRealityToolkit »