Extension OpenXR XR_ANDROID_face_tracking

Chaîne de nom

XR_ANDROID_face_tracking

Type d'extension

Extension d'instance

Numéro d'extension enregistré

459

Révision

3

Dépendances des extensions et des versions

OpenXR 1.0

Date de dernière modification

2025-06-04

État de l'adresse IP

Aucune réclamation connue pour atteinte à la propriété intellectuelle.

Contributeurs

Spencer Quin, Google

Jared Finder, Google

Levana Chen, Google

Présentation

Cette extension permet aux applications d'obtenir les pondérations des formes de mélange et d'afficher les expressions faciales dans les expériences XR.

Cette extension est destinée à fournir les informations nécessaires pour créer des avatars réalistes et des représentations expressives des utilisateurs dans l'espace virtuel. L'application peut vérifier l'activation de la calibration faciale avant d'obtenir les pondérations des formes de mélange.

Face Tracker

Un détecteur de visage est un dispositif de détection qui suit les expressions faciales grâce à des flux d'images orientés vers l'utilisateur et au calibrage de la caméra. L'objectif principal de cette extension est de mapper les expressions faciales des utilisateurs sur leurs avatars dans une scène virtuelle.

Les données de suivi du visage sont des informations personnelles sensibles, étroitement liées à la confidentialité et à l'intégrité personnelles. Il est fortement recommandé que les applications qui stockent ou transfèrent des données de suivi du visage demandent toujours à l'utilisateur d'accepter activement et spécifiquement de le faire.

• Les applications recevront XR_ERROR_PERMISSION_INSUFFICIENT lors de la création d'un détecteur de visage actif jusqu'à ce qu'elles soient autorisées à y accéder.
• Lorsque vous obtenez des états de visage à l'aide de xrGetFaceStateANDROID, XrFaceStateANDROID::isValid ne renvoie pas XR_TRUE, sauf si l'accès à l'application a été autorisé.

Inspecter les capacités du système

La structure XrSystemFaceTrackingPropertiesANDROID est définie comme suit :

typedef struct XrSystemFaceTrackingPropertiesANDROID {
    XrStructureType    type;
    void*              next;
    XrBool32           supportsFaceTracking;
} XrSystemFaceTrackingPropertiesANDROID;

Descriptions des membres

• type est le XrStructureType de cette structure.
• next est NULL ou un pointeur vers la structure suivante dans une chaîne de structures.
• supportsFaceTracking est un XrBool32 indiquant si le système actuel est compatible avec le suivi du visage.

Une application peut vérifier si le système est capable de suivre les visages en étendant XrSystemProperties avec la structure XrSystemFaceTrackingPropertiesANDROID lors de l'appel de xrGetSystemProperties.

Si et seulement si un environnement d'exécution renvoie XR_FALSE pour supportsFaceTracking, l'environnement d'exécution doit renvoyer XR_ERROR_FEATURE_UNSUPPORTED à partir de xrCreateFaceTrackerANDROID.

Créer un handle de suivi du visage

XR_DEFINE_HANDLE(XrFaceTrackerANDROID)

Le handle XrFaceTrackerANDROID représente un outil de suivi du visage pour le suivi du visage.

Ce handle peut être utilisé pour accéder aux données de suivi du visage à l'aide d'autres fonctions de cette extension.

La fonction xrCreateFaceTrackerANDROID est définie comme suit :

XrResult xrCreateFaceTrackerANDROID(
    XrSession                                   session,
    const XrFaceTrackerCreateInfoANDROID*       createInfo,
    XrFaceTrackerANDROID*                       faceTracker);

Descriptions des paramètres

• session est un handle XrSession dans lequel le détecteur de visage sera actif.
• createInfo est le XrFaceTrackerCreateInfoANDROID utilisé pour spécifier le détecteur de visage.
• faceTracker est le handle XrFaceTrackerANDROID renvoyé.

Une application peut créer un handle XrFaceTrackerANDROID à l'aide de la fonction xrCreateFaceTrackerANDROID.

Si le système n'est pas compatible avec le suivi du visage, xrCreateFaceTrackerANDROID renvoie XR_ERROR_FEATURE_UNSUPPORTED.

Utilisation valide (implicite)

• L'extension XR_ANDROID_face_tracking doit être activée avant d'appeler xrCreateFaceTrackerANDROID.
• session doit être un handle XrSession valide
• createInfo doit être un pointeur vers une structure XrFaceTrackerCreateInfoANDROID valide.
• faceTracker doit être un pointeur vers un handle XrFaceTrackerANDROID.

Codes de retour

Opération réussie

• XR_SUCCESS
• XR_SESSION_LOSS_PENDING

Échec

• XR_ERROR_FUNCTION_UNSUPPORTED
• XR_ERROR_VALIDATION_FAILURE
• XR_ERROR_RUNTIME_FAILURE
• XR_ERROR_HANDLE_INVALID
• XR_ERROR_INSTANCE_LOST
• XR_ERROR_SESSION_LOST
• XR_ERROR_OUT_OF_MEMORY
• XR_ERROR_LIMIT_REACHED

La structure XrFaceTrackerCreateInfoANDROID est décrite comme suit :

typedef struct XrFaceTrackerCreateInfoANDROID {
    XrStructureType    type;
    void*              next;
} XrFaceTrackerCreateInfoANDROID;

Descriptions des membres

• type est le XrStructureType de cette structure.
• next est NULL ou un pointeur vers la structure suivante dans une chaîne de structures. Aucune structure de ce type n'est définie dans l'extension ni dans le cœur d'OpenXR.

La structure XrFaceTrackerCreateInfoANDROID décrit les informations permettant de créer un handle XrFaceTrackerANDROID.

Utilisation valide (implicite)

• L'extension XR_ANDROID_face_tracking doit être activée avant d'utiliser XrFaceTrackerCreateInfoANDROID.
• type doit être XR_TYPE_FACE_TRACKER_CREATE_INFO_ANDROID.
• next doit être NULL ou un pointeur valide vers la structure suivante dans une chaîne de structures.

La fonction xrDestroyFaceTrackerANDROID est définie comme suit :

XrResult xrDestroyFaceTrackerANDROID(
    XrFaceTrackerANDROID                        faceTracker);

Descriptions des paramètres

• faceTracker est un XrFaceTrackerANDROID créé précédemment par xrCreateFaceTrackerANDROID.

La fonction xrDestroyFaceTrackerANDROID libère faceTracker et les ressources sous-jacentes lorsque l'expérience de suivi du visage est terminée.

Utilisation valide (implicite)

• L'extension XR_ANDROID_face_tracking doit être activée avant d'appeler xrDestroyFaceTrackerANDROID.
• faceTracker doit être un handle XrFaceTrackerANDROID valide

Sécurité des threads

• L'accès à faceTracker et à tous les handles enfants doit être synchronisé en externe.

Codes de retour

Opération réussie

• XR_SUCCESS

Échec

• XR_ERROR_FUNCTION_UNSUPPORTED
• XR_ERROR_HANDLE_INVALID

Vérifier la calibration du visage

La fonction xrGetFaceCalibrationStateANDROID est définie comme suit :

XrResult xrGetFaceCalibrationStateANDROID(
    XrFaceTrackerANDROID                        faceTracker,
    XrBool32*                                   faceIsCalibratedOutput);

Descriptions des paramètres

• faceTracker est un XrFaceTrackerANDROID créé précédemment par xrCreateFaceTrackerANDROID.
• faceIsCalibratedOutput indique si le détecteur de visage a été calibré ou non.

Une application peut vérifier l'état de la calibration du visage à l'aide de la fonction xrGetFaceCalibrationStateANDROID.

Lorsque le service de suivi est encore en cours d'initialisation, le runtime peut renvoyer XR_ERROR_SERVICE_NOT_READY_ANDROID à partir de xrGetFaceCalibrationStateANDROID pour indiquer que l'application peut réessayer ultérieurement.

Si le système n'est pas compatible avec la calibration du visage, xrGetFaceCalibrationStateANDROID renvoie XR_ERROR_FEATURE_UNSUPPORTED. Sinon, faceIsCalibratedOutput peut être défini sur XR_TRUE pour refléter l'état de la calibration du visage.

Utilisation valide (implicite)

• L'extension XR_ANDROID_face_tracking doit être activée avant d'appeler xrGetFaceCalibrationStateANDROID.
• faceTracker doit être un handle XrFaceTrackerANDROID valide
• faceIsCalibratedOutput doit être un pointeur vers une valeur XrBool32.

Codes de retour

Opération réussie

• XR_SUCCESS
• XR_SESSION_LOSS_PENDING

Échec

• XR_ERROR_FUNCTION_UNSUPPORTED
• XR_ERROR_VALIDATION_FAILURE
• XR_ERROR_RUNTIME_FAILURE
• XR_ERROR_HANDLE_INVALID
• XR_ERROR_INSTANCE_LOST
• XR_ERROR_SESSION_LOST
• XR_ERROR_OUT_OF_MEMORY
• XR_ERROR_LIMIT_REACHED
• XR_ERROR_SERVICE_NOT_READY_ANDROID

Obtenir des expressions faciales

La fonction xrGetFaceStateANDROID renvoie les formes de mélange des expressions faciales à un moment donné.

XrResult xrGetFaceStateANDROID(
    XrFaceTrackerANDROID                        faceTracker,
    const XrFaceStateGetInfoANDROID*            getInfo,
    XrFaceStateANDROID*                         faceStateOutput);

Descriptions des paramètres

• faceTracker est un XrFaceTrackerANDROID créé précédemment par xrCreateFaceTrackerANDROID.
• getInfo est un pointeur vers XrFaceStateGetInfoANDROID décrivant les informations permettant d'obtenir les expressions faciales.
• faceStateOutput est un pointeur vers XrFaceStateANDROID qui reçoit l'état de suivi du visage et les expressions faciales renvoyés.

Utilisation valide (implicite)

• L'extension XR_ANDROID_face_tracking doit être activée avant d'appeler xrGetFaceStateANDROID.
• faceTracker doit être un handle XrFaceTrackerANDROID valide
• getInfo must doit être un pointeur vers une structure XrFaceStateGetInfoANDROID valide.
• faceStateOutput doit être un pointeur vers une structure XrFaceStateANDROID.

Codes de retour

Opération réussie

• XR_SUCCESS
• XR_SESSION_LOSS_PENDING

Échec

• XR_ERROR_FUNCTION_UNSUPPORTED
• XR_ERROR_VALIDATION_FAILURE
• XR_ERROR_RUNTIME_FAILURE
• XR_ERROR_HANDLE_INVALID
• XR_ERROR_INSTANCE_LOST
• XR_ERROR_SESSION_LOST
• XR_ERROR_OUT_OF_MEMORY
• XR_ERROR_LIMIT_REACHED
• XR_ERROR_TIME_INVALID

La structure XrFaceStateGetInfoANDROID décrit les informations à obtenir sur les expressions faciales.

typedef struct XrFaceStateGetInfoANDROID {
    XrStructureType    type;
    void*              next;
    XrTime             time;
} XrFaceStateGetInfoANDROID;

Descriptions des membres

• type est le XrStructureType de cette structure.
• next est NULL ou un pointeur vers la structure suivante dans une chaîne de structures. Aucune structure de ce type n'est définie dans l'extension ni dans le cœur d'OpenXR.
• time est un XrTime auquel les expressions faciales sont demandées.

Les applications doivent demander une durée égale à la durée d'affichage prévue pour le frame rendu.

Utilisation valide (implicite)

• L'extension XR_ANDROID_face_tracking doit être activée avant d'utiliser XrFaceStateGetInfoANDROID.
• type doit être XR_TYPE_FACE_STATE_GET_INFO_ANDROID.
• next doit être NULL ou un pointeur valide vers la structure suivante dans une chaîne de structures.

La structure XrFaceStateANDROID renvoie l'état du suivi du visage et les expressions faciales.

typedef struct XrFaceStateANDROID {
    XrStructureType               type;
    void*                         next;
    uint32_t                      parametersCapacityInput;
    uint32_t                      parametersCountOutput;
    float*                        parameters;
    XrFaceTrackingStateANDROID    faceTrackingState;
    XrTime                        sampleTime;
    XrBool32                      isValid;
    uint32_t                      regionConfidencesCapacityInput;
    uint32_t                      regionConfidencesCountOutput;
    float*                        regionConfidences;
} XrFaceStateANDROID;

Descriptions des membres

• type est le XrStructureType de cette structure.
• next est NULL ou un pointeur vers la structure suivante dans une chaîne de structures. Aucune structure de ce type n'est définie dans l'extension ni dans le cœur d'OpenXR.
• parametersCapacityInput est un uint32_t décrivant la capacité du tableau parameters, ou 0 pour indiquer une demande de récupération de la capacité requise.
• parametersCountOutput est un uint32_t décrivant le nombre de parameters ou la capacité requise si parametersCapacityInput est insuffisant.
• parameters est un pointeur vers un tableau float alloué à l'application, qui sera rempli avec les pondérations des formes de mélange d'expressions faciales.
• faceTrackingState correspond à l'XrFaceTrackingStateANDROID de l'état de validité du suivi du visage.
• sampleTime est une heure XrTime à laquelle les expressions renvoyées sont suivies ou extrapolées. Elle est égale à l'heure à laquelle les pondérations d'expression ont été demandées si l'extrapolation à ce moment-là a réussi.
• isValid indique si les données sont valides même si elles ne proviennent pas du frame actuel.
• regionConfidencesCapacityInput est un uint32_t décrivant la capacité du tableau regionConfidences, ou 0 pour indiquer une demande de récupération de la capacité requise.
• regionConfidencesCountOutput est un uint32_t décrivant le nombre de regionConfidences ou la capacité requise si regionConfidencesCapacityInput est insuffisant.
• regionConfidences est un pointeur vers un tableau float alloué par l'application, qui sera rempli avec les valeurs de confiance pour chaque région du visage.
• Consultez la section Paramètres de taille du tampon pour obtenir une description détaillée de la récupération de la taille parameters et regionConfidences requise.

L'application peut définir parametersCapacityInput sur XR_FACE_PARAMETER_COUNT_ANDROID pour obtenir des expressions faciales indexées par XrFaceParameterIndicesANDROID.

Les parameters renvoyés représentent les pondérations des formes de mélange des expressions faciales actuelles.

Les mises à jour du tableau parameters seront ordonnées de sorte que l'application puisse indexer les éléments à l'aide de l'énumération d'expression faciale correspondante (par exemple, XrFaceParameterIndicesANDROID).

Utilisation valide (implicite)

• L'extension XR_ANDROID_face_tracking doit être activée avant d'utiliser XrFaceStateANDROID.
• type doit être XR_TYPE_FACE_STATE_ANDROID.
• next doit être NULL ou un pointeur valide vers la structure suivante dans une chaîne de structures.
• Si parametersCapacityInput n'est pas 0, parameters, must doit être un pointeur vers un tableau de valeurs parametersCapacityInput float.
• Si regionConfidencesCapacityInput n'est pas 0, regionConfidences, must doit être un pointeur vers un tableau de valeurs regionConfidencesCapacityInput float.
• faceTrackingState doit être une valeur XrFaceTrackingStateANDROID valide.

L'énumération XrFaceTrackingStateANDROID identifie les différents états du détecteur de visage.

typedef enum XrFaceTrackingStateANDROID {
    XR_FACE_TRACKING_STATE_PAUSED_ANDROID = 0,
    XR_FACE_TRACKING_STATE_STOPPED_ANDROID = 1,
    XR_FACE_TRACKING_STATE_TRACKING_ANDROID = 2
} XrFaceTrackingStateANDROID;

Les énumérations ont les significations suivantes :

Régions de confiance

L'extension XR_ANDROID_face_tracking fournit également des valeurs de confiance pour trois régions du visage : l'œil gauche, l'œil droit et la partie inférieure du visage. Ces valeurs, qui vont de 0 (aucune confiance) à 1 (confiance maximale), indiquent la précision du suivi du visage pour chaque région.

Vous pouvez utiliser ces valeurs de confiance pour désactiver progressivement les blendshapes ou appliquer des filtres visuels (comme le flou) à la région du visage correspondante. Pour un contrôle de base (activation/désactivation), nous vous recommandons d'utiliser un seuil de 0,3 pour désactiver complètement les blendshapes dans la région du visage correspondante.

La zone "bas du visage" représente tout ce qui se trouve sous les yeux, y compris la bouche, le menton, les joues et le nez. La région des yeux comprend les yeux et la zone des sourcils.

Le tableau suivant décrit les blendshapes associés à chaque région de confiance :

Conventions des formes de mélange

Cette extension définit 68 formes de mélange via XR_FACE_PARAMETER_COUNT_ANDROID pour le format G-Nome réduit. Chaque paramètre de cet énumérateur est un index dans un tableau de formes de fusion dont les valeurs sont de type float et dont l'exécution est normalisée à 1 – 0.

typedef enum XrFaceParameterIndicesANDROID {
    XR_FACE_PARAMETER_INDICES_BROW_LOWERER_L_ANDROID = 0,
    XR_FACE_PARAMETER_INDICES_BROW_LOWERER_R_ANDROID = 1,
    XR_FACE_PARAMETER_INDICES_CHEEK_PUFF_L_ANDROID = 2,
    XR_FACE_PARAMETER_INDICES_CHEEK_PUFF_R_ANDROID = 3,
    XR_FACE_PARAMETER_INDICES_CHEEK_RAISER_L_ANDROID = 4,
    XR_FACE_PARAMETER_INDICES_CHEEK_RAISER_R_ANDROID = 5,
    XR_FACE_PARAMETER_INDICES_CHEEK_SUCK_L_ANDROID = 6,
    XR_FACE_PARAMETER_INDICES_CHEEK_SUCK_R_ANDROID = 7,
    XR_FACE_PARAMETER_INDICES_CHIN_RAISER_B_ANDROID = 8,
    XR_FACE_PARAMETER_INDICES_CHIN_RAISER_T_ANDROID = 9,
    XR_FACE_PARAMETER_INDICES_DIMPLER_L_ANDROID = 10,
    XR_FACE_PARAMETER_INDICES_DIMPLER_R_ANDROID = 11,
    XR_FACE_PARAMETER_INDICES_EYES_CLOSED_L_ANDROID = 12,
    XR_FACE_PARAMETER_INDICES_EYES_CLOSED_R_ANDROID = 13,
    XR_FACE_PARAMETER_INDICES_EYES_LOOK_DOWN_L_ANDROID = 14,
    XR_FACE_PARAMETER_INDICES_EYES_LOOK_DOWN_R_ANDROID = 15,
    XR_FACE_PARAMETER_INDICES_EYES_LOOK_LEFT_L_ANDROID = 16,
    XR_FACE_PARAMETER_INDICES_EYES_LOOK_LEFT_R_ANDROID = 17,
    XR_FACE_PARAMETER_INDICES_EYES_LOOK_RIGHT_L_ANDROID = 18,
    XR_FACE_PARAMETER_INDICES_EYES_LOOK_RIGHT_R_ANDROID = 19,
    XR_FACE_PARAMETER_INDICES_EYES_LOOK_UP_L_ANDROID = 20,
    XR_FACE_PARAMETER_INDICES_EYES_LOOK_UP_R_ANDROID = 21,
    XR_FACE_PARAMETER_INDICES_INNER_BROW_RAISER_L_ANDROID = 22,
    XR_FACE_PARAMETER_INDICES_INNER_BROW_RAISER_R_ANDROID = 23,
    XR_FACE_PARAMETER_INDICES_JAW_DROP_ANDROID = 24,
    XR_FACE_PARAMETER_INDICES_JAW_SIDEWAYS_LEFT_ANDROID = 25,
    XR_FACE_PARAMETER_INDICES_JAW_SIDEWAYS_RIGHT_ANDROID = 26,
    XR_FACE_PARAMETER_INDICES_JAW_THRUST_ANDROID = 27,
    XR_FACE_PARAMETER_INDICES_LID_TIGHTENER_L_ANDROID = 28,
    XR_FACE_PARAMETER_INDICES_LID_TIGHTENER_R_ANDROID = 29,
    XR_FACE_PARAMETER_INDICES_LIP_CORNER_DEPRESSOR_L_ANDROID = 30,
    XR_FACE_PARAMETER_INDICES_LIP_CORNER_DEPRESSOR_R_ANDROID = 31,
    XR_FACE_PARAMETER_INDICES_LIP_CORNER_PULLER_L_ANDROID = 32,
    XR_FACE_PARAMETER_INDICES_LIP_CORNER_PULLER_R_ANDROID = 33,
    XR_FACE_PARAMETER_INDICES_LIP_FUNNELER_LB_ANDROID = 34,
    XR_FACE_PARAMETER_INDICES_LIP_FUNNELER_LT_ANDROID = 35,
    XR_FACE_PARAMETER_INDICES_LIP_FUNNELER_RB_ANDROID = 36,
    XR_FACE_PARAMETER_INDICES_LIP_FUNNELER_RT_ANDROID = 37,
    XR_FACE_PARAMETER_INDICES_LIP_PRESSOR_L_ANDROID = 38,
    XR_FACE_PARAMETER_INDICES_LIP_PRESSOR_R_ANDROID = 39,
    XR_FACE_PARAMETER_INDICES_LIP_PUCKER_L_ANDROID = 40,
    XR_FACE_PARAMETER_INDICES_LIP_PUCKER_R_ANDROID = 41,
    XR_FACE_PARAMETER_INDICES_LIP_STRETCHER_L_ANDROID = 42,
    XR_FACE_PARAMETER_INDICES_LIP_STRETCHER_R_ANDROID = 43,
    XR_FACE_PARAMETER_INDICES_LIP_SUCK_LB_ANDROID = 44,
    XR_FACE_PARAMETER_INDICES_LIP_SUCK_LT_ANDROID = 45,
    XR_FACE_PARAMETER_INDICES_LIP_SUCK_RB_ANDROID = 46,
    XR_FACE_PARAMETER_INDICES_LIP_SUCK_RT_ANDROID = 47,
    XR_FACE_PARAMETER_INDICES_LIP_TIGHTENER_L_ANDROID = 48,
    XR_FACE_PARAMETER_INDICES_LIP_TIGHTENER_R_ANDROID = 49,
    XR_FACE_PARAMETER_INDICES_LIPS_TOWARD_ANDROID = 50,
    XR_FACE_PARAMETER_INDICES_LOWER_LIP_DEPRESSOR_L_ANDROID = 51,
    XR_FACE_PARAMETER_INDICES_LOWER_LIP_DEPRESSOR_R_ANDROID = 52,
    XR_FACE_PARAMETER_INDICES_MOUTH_LEFT_ANDROID = 53,
    XR_FACE_PARAMETER_INDICES_MOUTH_RIGHT_ANDROID = 54,
    XR_FACE_PARAMETER_INDICES_NOSE_WRINKLER_L_ANDROID = 55,
    XR_FACE_PARAMETER_INDICES_NOSE_WRINKLER_R_ANDROID = 56,
    XR_FACE_PARAMETER_INDICES_OUTER_BROW_RAISER_L_ANDROID = 57,
    XR_FACE_PARAMETER_INDICES_OUTER_BROW_RAISER_R_ANDROID = 58,
    XR_FACE_PARAMETER_INDICES_UPPER_LID_RAISER_L_ANDROID = 59,
    XR_FACE_PARAMETER_INDICES_UPPER_LID_RAISER_R_ANDROID = 60,
    XR_FACE_PARAMETER_INDICES_UPPER_LIP_RAISER_L_ANDROID = 61,
    XR_FACE_PARAMETER_INDICES_UPPER_LIP_RAISER_R_ANDROID = 62,
    XR_FACE_PARAMETER_INDICES_TONGUE_OUT_ANDROID = 63,
    XR_FACE_PARAMETER_INDICES_TONGUE_LEFT_ANDROID = 64,
    XR_FACE_PARAMETER_INDICES_TONGUE_RIGHT_ANDROID = 65,
    XR_FACE_PARAMETER_INDICES_TONGUE_UP_ANDROID = 66,
    XR_FACE_PARAMETER_INDICES_TONGUE_DOWN_ANDROID = 67
} XrFaceParameterIndicesANDROID;

Index	Nom	Image de référence
0	BROW_LOWERER_L
1	BROW_LOWERER_R
2	CHEEK_PUFF_L
3	CHEEK_PUFF_R
4	CHEEK_RAISER_L
5	CHEEK_RAISER_R
6	CHEEK_SUCK_L
7	CHEEK_SUCK_R
8	CHIN_RAISER_B
9	CHIN_RAISER_T
10	DIMPLER_L
11	DIMPLER_R
12	EYES_CLOSED_L
13	EYES_CLOSED_R
14	EYES_LOOK_DOWN_L
15	EYES_LOOK_DOWN_R
16	EYES_LOOK_LEFT_L
17	EYES_LOOK_LEFT_R
18	EYES_LOOK_RIGHT_L
19	EYES_LOOK_RIGHT_R
20	EYES_LOOK_UP_L
21	EYES_LOOK_UP_R
22	INNER_BROW_RAISER_L
23	INNER_BROW_RAISER_R
24	JAW_DROP
25	JAW_SIDEWAYS_LEFT
26	JAW_SIDEWAYS_RIGHT
27	JAW_THRUST
28	LID_TIGHTENER_L
29	LID_TIGHTENER_R
30	LIP_CORNER_DEPRESSOR_L
31	LIP_CORNER_DEPRESSOR_R
32	LIP_CORNER_PULLER_L
33	LIP_CORNER_PULLER_R
34	LIP_FUNNELER_LB
35	LIP_FUNNELER_LT
36	LIP_FUNNELER_RB
37	LIP_FUNNELER_RT
38	LIP_PRESSOR_L
39	LIP_PRESSOR_R
40	LIP_PUCKER_L
41	LIP_PUCKER_R
42	LIP_STRETCHER_L
43	LIP_STRETCHER_R
44	LIP_SUCK_LB
45	LIP_SUCK_LT
46	LIP_SUCK_RB
47	LIP_SUCK_RT
48	LIP_TIGHTENER_L
49	LIP_TIGHTENER_R
50	LIPS_TOWARD
51	LOWER_LIP_DEPRESSOR_L
52	LOWER_LIP_DEPRESSOR_R
53	MOUTH_LEFT
54	MOUTH_RIGHT
55	NOSE_WRINKLER_L
56	NOSE_WRINKLER_R
57	OUTER_BROW_RAISER_L
58	OUTER_BROW_RAISER_R
59	UPPER_LID_RAISER_L
60	UPPER_LID_RAISER_R
61	UPPER_LIP_RAISER_L
62	UPPER_LIP_RAISER_R
63	TIRER_LA_LANGUE
64	TONGUE_LEFT
65	TONGUE_RIGHT
66	LANGUE_EN_HAUT
67	TONGUE_DOWN

Exemple de code pour le suivi du visage

L'exemple de code suivant montre comment obtenir tous les poids pour les formes de mélange d'expressions faciales.

XrInstance instance; // previously initialized
XrSystemId systemId; // previously initialized
XrSession session; // previously initialized, e.g. created at app startup.

// The function pointers are previously initialized using xrGetInstanceProcAddr.
PFN_xrCreateFaceTrackerANDROID xrCreateFaceTrackerANDROID; // previously initialized
PFN_xrDestroyFaceTrackerANDROID xrDestroyFaceTrackerANDROID; // previously initialized
PFN_xrGetFaceStateANDROID xrGetFaceStateANDROID; // previously initialized
PFN_xrGetFaceCalibrationStateANDROID xrGetFaceCalibrationStateANDROID; // previously initialized

// Inspect system capability
XrSystemProperties properties{XR_TYPE_SYSTEM_PROPERTIES};
XrSystemFaceTrackingPropertiesANDROID faceTrackingProperties{XR_TYPE_SYSTEM_FACE_TRACKING_PROPERTIES_ANDROID};
properties.next = &faceTrackingProperties;
CHK_XR(xrGetSystemProperties(instance, systemId, &properties));
if (!faceTrackingProperties.supportsFaceTracking) {
  // face tracking is not supported.
  return;
}

XrFaceTrackerANDROID faceTracker;
XrFaceTrackerCreateInfoANDROID
        createInfo{.type = XR_TYPE_FACE_TRACKER_CREATE_INFO_ANDROID,
                    .next = nullptr};
CHK_XR(xrCreateFaceTrackerANDROID(session, &createInfo, &faceTracker));

// If the system supports face calibration:
XrBool32 isCalibrated;
CHK_XR(xrGetFaceCalibrationStateANDROID(faceTracker, &isCalibrated));
if (!isCalibrated) {
    // Redirect the user to system calibration setting.
}

XrFaceStateANDROID faceState;
float faceExpressionParameters[XR_FACE_PARAMETER_COUNT_ANDROID];
faceState.type = XR_TYPE_FACE_STATE_ANDROID;
faceState.next = nullptr;
faceState.parametersCapacityInput = XR_FACE_PARAMETER_COUNT_ANDROID;
faceState.parameters = faceExpressionParameters;
float regionConfidences[XR_FACE_REGION_CONFIDENCE_COUNT_ANDROID];
faceState.regionConfidencesCapacityInput = XR_FACE_REGION_CONFIDENCE_COUNT_ANDROID;
faceState.regionConfidences = regionConfidences;

while (1) {
    // ...
    // For every frame in the frame loop
    // ...
    XrFrameState frameState; // previously returned from xrWaitFrame

    XrFaceStateGetInfoANDROID faceGetInfo{
            .type = XR_TYPE_FACE_STATE_GET_INFO_ANDROID,
            .next = nullptr,
            .time = frameState.predictedDisplayTime,
    };

    CHK_XR(xrGetFaceStateANDROID(faceTracker, &faceGetInfo, &faceState));
    if (faceState.isValid) {
        for (uint32_t i = 0; i < XR_FACE_PARAMETER_COUNT_ANDROID; ++i) {
            // parameters[i] contains a weight of specific blend shape
        }
        for (uint32_t i = 0; i < XR_FACE_REGION_CONFIDENCE_COUNT_ANDROID; ++i) {
            // regionConfidences[i] contains a confidence value of a specific region
        }
    }
}

// after usage
CHK_XR(xrDestroyFaceTrackerANDROID(faceTracker));

Nouveaux types d'objets

• XrFaceTrackerANDROID

Nouvelles constantes d'énumération

• XR_FACE_PARAMETER_COUNT_ANDROID

L'énumération XrObjectType est étendue avec les éléments suivants :

• XR_OBJECT_TYPE_FACE_TRACKER_ANDROID

L'énumération XrStructureType est étendue avec les éléments suivants :

• XR_TYPE_FACE_TRACKER_CREATE_INFO_ANDROID
• XR_TYPE_FACE_STATE_GET_INFO_ANDROID
• XR_TYPE_FACE_STATE_ANDROID
• XR_TYPE_SYSTEM_FACE_TRACKING_PROPERTIES_ANDROID

Nouvelles énumérations

• XrFaceParameterIndicesANDROID
• XrFaceTrackingStateANDROID

Nouvelles structures

• XrFaceTrackerCreateInfoANDROID
• XrFaceStateGetInfoANDROID
• XrFaceStateANDROID
• XrSystemFaceTrackingPropertiesANDROID

Nouvelles fonctions

• xrCreateFaceTrackerANDROID
• xrDestroyFaceTrackerANDROID
• xrGetFaceStateANDROID
• xrGetFaceCalibrationStateANDROID

Problèmes

Historique des versions

• Révision 1, 2024-09-05 (Levana Chen)
  • Description initiale de l'extension
• Révision 2, 2025-04-01 (Kenny Vercaemer)
  • Ajout de régions de confiance pour les visages
• Révision 3, 2025-06-04 (Levana Chen)
  • Ajout d'un code d'erreur.

OpenXR™ et le logo OpenXR sont des marques déposées appartenant à The Khronos Group Inc. et sont enregistrées en Chine, dans l'Union européenne, au Japon et au Royaume-Uni.