Extensión OpenXR XR_ANDROID_face_tracking

Cadena de nombre

XR_ANDROID_face_tracking

Tipo de extensión

Extensión de la instancia

Número de extensión registrado

459

Revisión

3

Dependencias de extensiones y versiones

OpenXR 1.0

Fecha de la última modificación

2025-06-04

Estado de la IP

No hay reclamos conocidos por IP.

Colaboradores

Spencer Quin, de Google

Jared Finder, Google

Levana Chen, de Google

Descripción general

Esta extensión permite que las aplicaciones obtengan pesos de formas de combinación y rendericen expresiones faciales en experiencias de XR.

El objetivo de esta extensión es proporcionar la información necesaria para crear avatares realistas y representaciones expresivas de los usuarios en el espacio virtual. La aplicación puede verificar la activación de la calibración facial antes de obtener los pesos de las formas de combinación.

Face Tracker

Un dispositivo de seguimiento facial es un sensor que rastrea la expresión facial a través de transmisiones de imágenes orientadas al usuario y la calibración de la cámara. El objetivo principal de esta extensión es asignar las expresiones faciales del usuario a sus avatares en una escena virtual.

Los datos de seguimiento facial son información personal sensible y están estrechamente vinculados a la privacidad y la integridad personales. Se recomienda encarecidamente que las aplicaciones que almacenan o transfieren datos de seguimiento facial siempre soliciten al usuario su aceptación activa y específica para hacerlo.

• Las aplicaciones recibirán XR_ERROR_PERMISSION_INSUFFICIENT cuando creen un rastreador facial activo hasta que se les permita acceder a él.
• Cuando se obtienen estados faciales con xrGetFaceStateANDROID, XrFaceStateANDROID::isValid no devolverá XR_TRUE, a menos que se haya permitido el acceso de la aplicación.

Inspecciona la capacidad del sistema

La estructura XrSystemFaceTrackingPropertiesANDROID se define de la siguiente manera:

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

Descripciones de los miembros

• type es el XrStructureType de esta estructura.
• next es NULL o un puntero a la siguiente estructura en una cadena de estructuras.
• supportsFaceTracking es un XrBool32 que indica si el sistema actual admite el seguimiento facial.

Una aplicación puede inspeccionar si el sistema es capaz de realizar el seguimiento facial extendiendo XrSystemProperties con la estructura XrSystemFaceTrackingPropertiesANDROID cuando se llama a xrGetSystemProperties.

Si y solo si un tiempo de ejecución devuelve XR_FALSE para supportsFaceTracking, el tiempo de ejecución debe devolver XR_ERROR_FEATURE_UNSUPPORTED de xrCreateFaceTrackerANDROID.

Crea un identificador de seguimiento facial

XR_DEFINE_HANDLE(XrFaceTrackerANDROID)

El controlador XrFaceTrackerANDROID representa un rastreador facial para el seguimiento de rostros.

Este identificador se puede usar para acceder a los datos de seguimiento facial con otras funciones de esta extensión.

La función xrCreateFaceTrackerANDROID se define de la siguiente manera:

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

Descripciones de los parámetros

• session es un identificador de XrSession en el que el rastreador facial estará activo.
• createInfo es el XrFaceTrackerCreateInfoANDROID que se usa para especificar el rastreador facial.
• faceTracker es el controlador XrFaceTrackerANDROID que se devolvió.

Una aplicación puede crear un identificador XrFaceTrackerANDROID con la función xrCreateFaceTrackerANDROID.

Si el sistema no admite el seguimiento de rostros, xrCreateFaceTrackerANDROID devolverá XR_ERROR_FEATURE_UNSUPPORTED.

Uso válido (implícito)

• La extensión XR_ANDROID_face_tracking debe habilitarse antes de llamar a xrCreateFaceTrackerANDROID.
• session debe ser un identificador de XrSession válido
• createInfo debe ser un puntero a una estructura XrFaceTrackerCreateInfoANDROID válida.
• faceTracker debe ser un puntero a un identificador de XrFaceTrackerANDROID.

Códigos de retorno

Listo

• XR_SUCCESS
• XR_SESSION_LOSS_PENDING

Falla

• 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 estructura XrFaceTrackerCreateInfoANDROID se describe de la siguiente manera:

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

Descripciones de los miembros

• type es el XrStructureType de esta estructura.
• next es NULL o un puntero a la siguiente estructura en una cadena de estructuras. No se definen tales estructuras en OpenXR básico ni en esta extensión.

La estructura XrFaceTrackerCreateInfoANDROID describe la información para crear un identificador XrFaceTrackerANDROID.

Uso válido (implícito)

• La extensión XR_ANDROID_face_tracking debe habilitarse antes de usar XrFaceTrackerCreateInfoANDROID.
• type debe ser XR_TYPE_FACE_TRACKER_CREATE_INFO_ANDROID
• next debe ser NULL o un puntero válido a la siguiente estructura en una cadena de estructuras

La función xrDestroyFaceTrackerANDROID se define de la siguiente manera:

XrResult xrDestroyFaceTrackerANDROID(
    XrFaceTrackerANDROID                        faceTracker);

Descripciones de los parámetros

• faceTracker es un objeto XrFaceTrackerANDROID creado previamente por xrCreateFaceTrackerANDROID.

La función xrDestroyFaceTrackerANDROID libera el faceTracker y los recursos subyacentes cuando finaliza la experiencia de seguimiento de rostro.

Uso válido (implícito)

• La extensión XR_ANDROID_face_tracking debe habilitarse antes de llamar a xrDestroyFaceTrackerANDROID.
• faceTracker debe ser un identificador XrFaceTrackerANDROID válido

Seguridad de subprocesos

• El acceso a faceTracker y a cualquier identificador secundario debe sincronizarse de forma externa.

Códigos de retorno

Listo

• XR_SUCCESS

Falla

• XR_ERROR_FUNCTION_UNSUPPORTED
• XR_ERROR_HANDLE_INVALID

Cómo verificar la calibración del rostro

La función xrGetFaceCalibrationStateANDROID se define de la siguiente manera:

XrResult xrGetFaceCalibrationStateANDROID(
    XrFaceTrackerANDROID                        faceTracker,
    XrBool32*                                   faceIsCalibratedOutput);

Descripciones de los parámetros

• faceTracker es un objeto XrFaceTrackerANDROID creado previamente por xrCreateFaceTrackerANDROID.
• faceIsCalibratedOutput indica si el rastreador facial se calibró o no.

Una aplicación puede verificar el estado de calibración del rostro con la función xrGetFaceCalibrationStateANDROID.

Cuando el servicio de seguimiento aún se está inicializando, el tiempo de ejecución puede devolver XR_ERROR_SERVICE_NOT_READY_ANDROID desde xrGetFaceCalibrationStateANDROID para indicar que la aplicación puede volver a intentarlo más tarde.

Si el sistema no admite la calibración facial, xrGetFaceCalibrationStateANDROID devolverá XR_ERROR_FEATURE_UNSUPPORTED. De lo contrario, faceIsCalibratedOutput se puede establecer en XR_TRUE para reflejar el estado de calibración del rostro.

Uso válido (implícito)

• La extensión XR_ANDROID_face_tracking debe habilitarse antes de llamar a xrGetFaceCalibrationStateANDROID.
• faceTracker debe ser un identificador XrFaceTrackerANDROID válido
• faceIsCalibratedOutput debe ser un puntero a un valor de XrBool32

Códigos de retorno

Listo

• XR_SUCCESS
• XR_SESSION_LOSS_PENDING

Falla

• 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

Obtener expresiones faciales

La función xrGetFaceStateANDROID devuelve formas de combinación de expresiones faciales en un momento determinado.

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

Descripciones de los parámetros

• faceTracker es un objeto XrFaceTrackerANDROID creado previamente por xrCreateFaceTrackerANDROID.
• getInfo es un puntero a XrFaceStateGetInfoANDROID que describe la información para obtener expresiones faciales.
• faceStateOutput es un puntero a XrFaceStateANDROID que recibe el estado de seguimiento facial y las expresiones faciales devueltos.

Uso válido (implícito)

• La extensión XR_ANDROID_face_tracking debe habilitarse antes de llamar a xrGetFaceStateANDROID.
• faceTracker debe ser un identificador XrFaceTrackerANDROID válido
• getInfo debe ser un puntero a una estructura XrFaceStateGetInfoANDROID válida.
• faceStateOutput debe ser un puntero a una estructura XrFaceStateANDROID.

Códigos de retorno

Listo

• XR_SUCCESS
• XR_SESSION_LOSS_PENDING

Falla

• 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 estructura XrFaceStateGetInfoANDROID describe la información para obtener expresiones faciales.

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

Descripciones de los miembros

• type es el XrStructureType de esta estructura.
• next es NULL o un puntero a la siguiente estructura en una cadena de estructuras. No se definen tales estructuras en OpenXR básico ni en esta extensión.
• time es un XrTime en el que se solicitan las expresiones faciales.

Las aplicaciones deben solicitar un tiempo igual al tiempo de visualización previsto para el fotograma renderizado.

Uso válido (implícito)

• La extensión XR_ANDROID_face_tracking debe habilitarse antes de usar XrFaceStateGetInfoANDROID.
• type debe ser XR_TYPE_FACE_STATE_GET_INFO_ANDROID
• next debe ser NULL o un puntero válido a la siguiente estructura en una cadena de estructuras

La estructura XrFaceStateANDROID devuelve el estado del seguimiento facial y las expresiones 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;

Descripciones de los miembros

• type es el XrStructureType de esta estructura.
• next es NULL o un puntero a la siguiente estructura en una cadena de estructuras. No se definen tales estructuras en OpenXR básico ni en esta extensión.
• parametersCapacityInput es un uint32_t que describe la capacidad del array parameters o 0 para indicar una solicitud para recuperar la capacidad requerida.
• parametersCountOutput es un uint32_t que describe la cantidad de parameters o la capacidad requerida en caso de que parametersCapacityInput sea insuficiente.
• parameters es un puntero a un array de float asignado por la aplicación que se completará con los pesos de las formas de combinación de expresiones faciales.
• faceTrackingState es el XrFaceTrackingStateANDROID del estado de validez del seguimiento facial.
• sampleTime es un momento XrTime en el que se hace un seguimiento de las expresiones devueltas o se extrapolan. Es igual al momento en el que se solicitaron los pesos de la expresión si la extrapolación en ese momento se realizó correctamente.
• isValid indica si los datos son válidos, incluso si no provienen del fotograma actual.
• regionConfidencesCapacityInput es un uint32_t que describe la capacidad del array regionConfidences o 0 para indicar una solicitud para recuperar la capacidad requerida.
• regionConfidencesCountOutput es un uint32_t que describe la cantidad de regionConfidences o la capacidad requerida en caso de que regionConfidencesCapacityInput sea insuficiente.
• regionConfidences es un puntero a un array de float asignado por la aplicación que se completará con valores de confianza para cada región facial.
• Consulta la sección Parámetros de tamaño del búfer para obtener una descripción detallada de cómo recuperar el tamaño requerido de parameters y regionConfidences.

La aplicación puede establecer parametersCapacityInput en XR_FACE_PARAMETER_COUNT_ANDROID para obtener expresiones faciales indexadas por XrFaceParameterIndicesANDROID.

Los valores parameters devueltos representan los pesos de las formas de combinación de las expresiones faciales actuales.

Las actualizaciones del array parameters se ordenarán de modo que la aplicación pueda indexar elementos con el enum de expresión facial correspondiente (p.ej., XrFaceParameterIndicesANDROID).

Uso válido (implícito)

• La extensión XR_ANDROID_face_tracking debe habilitarse antes de usar XrFaceStateANDROID.
• type debe ser XR_TYPE_FACE_STATE_ANDROID
• next debe ser NULL o un puntero válido a la siguiente estructura en una cadena de estructuras
• Si parametersCapacityInput no es 0, parameters, debe ser un puntero a un array de valores parametersCapacityInput float.
• Si regionConfidencesCapacityInput no es 0, regionConfidences, debe ser un puntero a un array de valores regionConfidencesCapacityInput float.
• faceTrackingState debe ser un valor XrFaceTrackingStateANDROID válido.

La enumeración XrFaceTrackingStateANDROID identifica los diferentes estados del rastreador de rostros.

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;

Los enums tienen los siguientes significados:

Regiones de confianza

La extensión XR_ANDROID_face_tracking también proporciona valores de confianza para tres regiones faciales: ojo izquierdo, ojo derecho y parte inferior del rostro. Estos valores, que van de 0 (sin confianza) a 1 (confianza más alta), indican la precisión del seguimiento facial para cada región.

Puedes usar estos valores de confianza para inhabilitar progresivamente las formas de combinación o aplicar filtros visuales (como el desenfoque) a la región facial correspondiente. Para un control básico de activación y desactivación, recomendamos usar un umbral de 0.3 para desactivar por completo las formas de combinación en la región facial correspondiente.

El área de la "parte inferior del rostro" representa todo lo que está debajo de los ojos, incluidos la boca, el mentón, las mejillas y la nariz. La región de los ojos incluye los ojos y el área de las cejas.

En la siguiente tabla, se describen los blendshapes asociados con cada región de confianza:

Convenciones de las formas de combinación

Esta extensión define 68 formas de combinación a través de XR_FACE_PARAMETER_COUNT_ANDROID para el formato reducido de G-Nome. Cada parámetro de esta enumeración es un índice en un array de formas de combinación cuyos valores son del tipo float y el tiempo de ejecución normaliza de 1 a 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;

Índice	Name	Imagen de referencia
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	OJOS_MIRAN_HACIA_ARRIBA_D
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	TONGUE_OUT
64	TONGUE_LEFT
65	TONGUE_RIGHT
66	TONGUE_UP
67	TONGUE_DOWN

Ejemplo de código para el seguimiento de rostros

En el siguiente código de ejemplo, se muestra cómo obtener todos los pesos de las formas de combinación de expresiones 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));

Nuevos tipos de objetos

• XrFaceTrackerANDROID

Nuevas constantes de enumeración

• XR_FACE_PARAMETER_COUNT_ANDROID

La enumeración XrObjectType se extiende con lo siguiente:

• XR_OBJECT_TYPE_FACE_TRACKER_ANDROID

Se extendió la enumeración XrStructureType con lo siguiente:

• 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

Nuevas enumeraciones

• XrFaceParameterIndicesANDROID
• XrFaceTrackingStateANDROID

Nuevas estructuras

• XrFaceTrackerCreateInfoANDROID
• XrFaceStateGetInfoANDROID
• XrFaceStateANDROID
• XrSystemFaceTrackingPropertiesANDROID

Nuevas funciones

• xrCreateFaceTrackerANDROID
• xrDestroyFaceTrackerANDROID
• xrGetFaceStateANDROID
• xrGetFaceCalibrationStateANDROID

Problemas

Historial de versiones

• Revisión 1, 2024-09-05 (Levana Chen)
  • Descripción inicial de la extensión
• Revisión 2, 2025-04-01 (Kenny Vercaemer)
  • Se agregaron regiones de confianza del rostro
• Revisión 3, 2025-06-04 (Levana Chen)
  • Se agregó un nuevo código de error.

OpenXR™ y el logotipo de OpenXR son marcas comerciales propiedad de The Khronos Group Inc. y están registradas como marcas comerciales en China, la Unión Europea, Japón y el Reino Unido.