Extensão OpenXR XR_ANDROID_face_tracking

String de nome

XR_ANDROID_face_tracking

Tipo de extensão

Extensão de instância

Número de ramal registrado

459

Revisão

3

Dependências de extensão e versão

OpenXR 1.0

Data da última modificação

2025-06-04

Status do IP

Não há reivindicações de IP conhecidas.

Colaboradores

Spencer Quin, Google

Jared Finder, Google

Levana Chen, Google

Visão geral

Essa extensão permite que os aplicativos recebam pesos de formas de combinação e renderizem expressões faciais em experiências de XR.

Ela foi criada para fornecer as informações necessárias para criar avatares realistas e representações expressivas de usuários no espaço virtual. O aplicativo pode verificar a ativação da calibragem facial antes de receber os pesos das formas de combinação.

Rastreamento de rostos

Um rastreador facial é um dispositivo de detecção que acompanha a expressão facial usando fluxos de imagens voltados para o usuário e calibragem da câmera. O objetivo principal dessa extensão é mapear as expressões faciais dos usuários para os avatares deles em uma cena virtual.

Os dados de rastreamento facial são informações pessoais sensíveis e estão intimamente ligados à privacidade e integridade pessoais. Recomendamos que os aplicativos que armazenam ou transferem dados de rastreamento facial sempre peçam ao usuário uma permissão ativa e específica para fazer isso.

• Os aplicativos vão receber XR_ERROR_PERMISSION_INSUFFICIENT ao criar um rastreador de rosto ativo até que o aplicativo tenha permissão para acessar o rastreador de rosto.
• Ao receber estados de rosto usando xrGetFaceStateANDROID, XrFaceStateANDROID::isValid não vai retornar XR_TRUE, a menos que o acesso do aplicativo tenha sido permitido.

Inspecionar a capacidade do sistema

A estrutura XrSystemFaceTrackingPropertiesANDROID é definida da seguinte forma:

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

Descrições de membros

• type é o XrStructureType dessa estrutura.
• next é NULL ou um ponteiro para a próxima estrutura em uma cadeia de estruturas.
• supportsFaceTracking é um XrBool32 que indica se o sistema atual é compatível com o rastreamento facial.

Um aplicativo pode inspecionar se o sistema é capaz de fazer o rastreamento facial estendendo o XrSystemProperties com a estrutura XrSystemFaceTrackingPropertiesANDROID ao chamar xrGetSystemProperties.

Se e somente se um ambiente de execução retornar XR_FALSE para supportsFaceTracking, o ambiente de execução deverá retornar XR_ERROR_FEATURE_UNSUPPORTED de xrCreateFaceTrackerANDROID.

Criar um handle para rastreador facial

XR_DEFINE_HANDLE(XrFaceTrackerANDROID)

O handle XrFaceTrackerANDROID representa um rastreador de rosto para rastreamento facial.

Esse identificador pode ser usado para acessar dados de rastreamento facial usando outras funções nesta extensão.

A função xrCreateFaceTrackerANDROID é definida como:

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

Descrições dos parâmetros

• session é um identificador XrSession em que o rastreador facial vai estar ativo.
• createInfo é o XrFaceTrackerCreateInfoANDROID usado para especificar o rastreador de rosto.
• faceTracker é o identificador XrFaceTrackerANDROID retornado.

Um aplicativo pode criar um identificador XrFaceTrackerANDROID usando a função xrCreateFaceTrackerANDROID.

Se o sistema não for compatível com o rastreamento facial, xrCreateFaceTrackerANDROID vai retornar XR_ERROR_FEATURE_UNSUPPORTED.

Uso válido (implícito)

• A extensão XR_ANDROID_face_tracking precisa ser ativada antes de chamar xrCreateFaceTrackerANDROID.
• session precisa ser um identificador XrSession válido
• createInfo precisa ser um ponteiro para uma estrutura XrFaceTrackerCreateInfoANDROID válida
• faceTracker precisa ser um ponteiro para um identificador XrFaceTrackerANDROID.

Códigos de retorno

Sucesso

• XR_SUCCESS
• XR_SESSION_LOSS_PENDING

Falha

• 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

A estrutura XrFaceTrackerCreateInfoANDROID é descrita da seguinte maneira:

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

Descrições de membros

• type é o XrStructureType dessa estrutura.
• next é NULL ou um ponteiro para a próxima estrutura em uma cadeia de estruturas. Nenhuma dessas estruturas é definida no OpenXR principal ou nesta extensão.

A estrutura XrFaceTrackerCreateInfoANDROID descreve as informações para criar um identificador XrFaceTrackerANDROID.

Uso válido (implícito)

• A extensão XR_ANDROID_face_tracking precisa ser ativada antes de usar XrFaceTrackerCreateInfoANDROID
• type precisa ser XR_TYPE_FACE_TRACKER_CREATE_INFO_ANDROID
• next precisa ser NULL ou um ponteiro válido para a próxima estrutura em uma cadeia de estruturas

A função xrDestroyFaceTrackerANDROID é definida como:

XrResult xrDestroyFaceTrackerANDROID(
    XrFaceTrackerANDROID                        faceTracker);

Descrições dos parâmetros

• faceTracker é um XrFaceTrackerANDROID criado anteriormente por xrCreateFaceTrackerANDROID.

A função xrDestroyFaceTrackerANDROID libera o faceTracker e os recursos subjacentes quando a experiência de rastreamento facial termina.

Uso válido (implícito)

• A extensão XR_ANDROID_face_tracking precisa ser ativada antes de chamar xrDestroyFaceTrackerANDROID
• faceTracker precisa ser um identificador XrFaceTrackerANDROID válido

Concorrência segura

• O acesso a faceTracker e a qualquer identificador filho precisa ser sincronizado externamente.

Códigos de retorno

Sucesso

• XR_SUCCESS

Falha

• XR_ERROR_FUNCTION_UNSUPPORTED
• XR_ERROR_HANDLE_INVALID

Verificar a calibragem do rosto

A função xrGetFaceCalibrationStateANDROID é definida como:

XrResult xrGetFaceCalibrationStateANDROID(
    XrFaceTrackerANDROID                        faceTracker,
    XrBool32*                                   faceIsCalibratedOutput);

Descrições dos parâmetros

• faceTracker é um XrFaceTrackerANDROID criado anteriormente por xrCreateFaceTrackerANDROID.
• faceIsCalibratedOutput indica se o rastreador de rosto foi calibrado ou não.

Um aplicativo pode verificar o estado da calibragem do rosto usando a função xrGetFaceCalibrationStateANDROID.

Quando o serviço de rastreamento ainda está sendo inicializado, o ambiente de execução pode retornar XR_ERROR_SERVICE_NOT_READY_ANDROID de xrGetFaceCalibrationStateANDROID para indicar que o aplicativo pode tentar de novo mais tarde.

Se o sistema não for compatível com a calibragem facial, xrGetFaceCalibrationStateANDROID vai retornar XR_ERROR_FEATURE_UNSUPPORTED. Caso contrário, faceIsCalibratedOutput pode ser definido como XR_TRUE para refletir o estado de calibragem do rosto.

Uso válido (implícito)

• A extensão XR_ANDROID_face_tracking precisa ser ativada antes de chamar xrGetFaceCalibrationStateANDROID
• faceTracker precisa ser um identificador XrFaceTrackerANDROID válido
• faceIsCalibratedOutput precisa ser um ponteiro para um valor XrBool32

Códigos de retorno

Sucesso

• XR_SUCCESS
• XR_SESSION_LOSS_PENDING

Falha

• 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

Receber expressões faciais

A função xrGetFaceStateANDROID retorna formas de combinação de expressões faciais em um determinado momento.

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

Descrições dos parâmetros

• faceTracker é um XrFaceTrackerANDROID criado anteriormente por xrCreateFaceTrackerANDROID.
• getInfo é um ponteiro para XrFaceStateGetInfoANDROID que descreve informações para obter expressões faciais.
• faceStateOutput é um ponteiro para XrFaceStateANDROID que recebe o estado de rastreamento de rosto e as expressões faciais retornadas.

Uso válido (implícito)

• A extensão XR_ANDROID_face_tracking precisa ser ativada antes de chamar xrGetFaceStateANDROID
• faceTracker precisa ser um identificador XrFaceTrackerANDROID válido
• getInfo precisa ser um ponteiro para uma estrutura XrFaceStateGetInfoANDROID válida.
• faceStateOutput precisa ser um ponteiro para uma estrutura XrFaceStateANDROID

Códigos de retorno

Sucesso

• XR_SUCCESS
• XR_SESSION_LOSS_PENDING

Falha

• 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

A estrutura XrFaceStateGetInfoANDROID descreve as informações para obter expressões faciais.

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

Descrições de membros

• type é o XrStructureType dessa estrutura.
• next é NULL ou um ponteiro para a próxima estrutura em uma cadeia de estruturas. Nenhuma dessas estruturas é definida no OpenXR principal ou nesta extensão.
• time é um XrTime em que as expressões faciais são solicitadas.

Os aplicativos devem solicitar um tempo igual ao tempo de exibição previsto para o frame renderizado.

Uso válido (implícito)

• A extensão XR_ANDROID_face_tracking precisa ser ativada antes de usar XrFaceStateGetInfoANDROID
• type precisa ser XR_TYPE_FACE_STATE_GET_INFO_ANDROID
• next precisa ser NULL ou um ponteiro válido para a próxima estrutura em uma cadeia de estruturas

A estrutura XrFaceStateANDROID retorna o estado de monitoramento facial e as expressões faciais.

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;

Descrições de membros

• type é o XrStructureType dessa estrutura.
• next é NULL ou um ponteiro para a próxima estrutura em uma cadeia de estruturas. Nenhuma dessas estruturas é definida no OpenXR principal ou nesta extensão.
• parametersCapacityInput é um uint32_t que descreve a capacidade da matriz parameters ou 0 para indicar uma solicitação de recuperação da capacidade necessária.
• parametersCountOutput é um uint32_t que descreve o número de parameters ou a capacidade necessária caso parametersCapacityInput seja insuficiente.
• parameters é um ponteiro para uma matriz alocada pelo aplicativo de float que será preenchida com ponderações de formas de combinação de expressões faciais.
• faceTrackingState é o XrFaceTrackingStateANDROID do status de validade do acompanhamento de rosto.
• sampleTime é um XrTime em que as expressões retornadas são rastreadas ou extrapoladas. É igual ao momento em que os pesos da expressão foram solicitados, se a extrapolação na época foi bem-sucedida.
• isValid indica se os dados são válidos mesmo que não sejam do frame atual.
• regionConfidencesCapacityInput é um uint32_t que descreve a capacidade da matriz regionConfidences ou 0 para indicar uma solicitação de recuperação da capacidade necessária.
• regionConfidencesCountOutput é um uint32_t que descreve o número de regionConfidences ou a capacidade necessária caso regionConfidencesCapacityInput seja insuficiente.
• regionConfidences é um ponteiro para uma matriz alocada pelo aplicativo de float que será preenchida com valores de confiança para cada região facial.
• Consulte a seção Parâmetros de tamanho do buffer para uma descrição detalhada de como recuperar o tamanho necessário de parameters e regionConfidences.

O aplicativo pode definir parametersCapacityInput como XR_FACE_PARAMETER_COUNT_ANDROID para receber expressões faciais indexadas por XrFaceParameterIndicesANDROID.

Os parameters retornados representam os pesos das formas de combinação das expressões faciais atuais.

As atualizações da matriz parameters serão ordenadas para que o aplicativo possa indexar elementos usando a enumeração de expressão facial correspondente (por exemplo, XrFaceParameterIndicesANDROID).

Uso válido (implícito)

• A extensão XR_ANDROID_face_tracking precisa ser ativada antes de usar XrFaceStateANDROID.
• type precisa ser XR_TYPE_FACE_STATE_ANDROID
• next precisa ser NULL ou um ponteiro válido para a próxima estrutura em uma cadeia de estruturas
• Se parametersCapacityInput não for 0, parameters, precisará ser um ponteiro para uma matriz de valores parametersCapacityInput float.
• Se regionConfidencesCapacityInput não for 0, regionConfidences, precisará ser um ponteiro para uma matriz de valores regionConfidencesCapacityInput float.
• faceTrackingState precisa ser um valor XrFaceTrackingStateANDROID válido

A enumeração XrFaceTrackingStateANDROID identifica os diferentes estados do rastreador facial.

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;

Os tipos enumerados têm os seguintes significados:

Regiões de confiança

A extensão XR_ANDROID_face_tracking também fornece valores de confiança para três regiões faciais: olho esquerdo, olho direito e parte inferior do rosto. Esses valores, que variam de 0 (nenhuma confiança) a 1 (maior confiança), indicam a precisão do rastreamento de rosto em cada região.

Você pode usar esses valores de confiança para desativar progressivamente as blendshapes ou aplicar filtros visuais (como desfoque) à região correspondente do rosto. Para um controle básico de ativação/desativação, recomendamos usar um limite de 0,3 para desativar totalmente as unidades de forma na região correspondente do rosto.

A área do "terço inferior do rosto" representa tudo abaixo dos olhos, incluindo a boca, o queixo, a bochecha e o nariz. A região dos olhos inclui os olhos e a área das sobrancelhas.

A tabela a seguir descreve as deformações associadas a cada região de confiança:

Convenções de formas de fusão

Essa extensão define 68 formas de combinação usando XR_FACE_PARAMETER_COUNT_ANDROID para o formato G-Nome reduzido. Cada parâmetro neste enum é um índice em uma matriz de formas combinadas cujos valores são do tipo float e o tempo de execução normaliza para 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	Nome	Imagem de referência
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	TONGUE_OUT
64	TONGUE_LEFT
65	TONGUE_RIGHT
66	TONGUE_UP
67	TONGUE_DOWN

Exemplo de código para rastreamento facial

O exemplo de código a seguir demonstra como receber todos os pesos para formas de combinação de expressões faciais.

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));

Novos tipos de objetos

• XrFaceTrackerANDROID

Novas constantes de enumeração

• XR_FACE_PARAMETER_COUNT_ANDROID

A enumeração XrObjectType é estendida com:

• XR_OBJECT_TYPE_FACE_TRACKER_ANDROID

A enumeração XrStructureType é estendida com:

• 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

Novos enums

• XrFaceParameterIndicesANDROID
• XrFaceTrackingStateANDROID

Novas estruturas

• XrFaceTrackerCreateInfoANDROID
• XrFaceStateGetInfoANDROID
• XrFaceStateANDROID
• XrSystemFaceTrackingPropertiesANDROID

Novas funções

• xrCreateFaceTrackerANDROID
• xrDestroyFaceTrackerANDROID
• xrGetFaceStateANDROID
• xrGetFaceCalibrationStateANDROID

Problemas

Histórico de versões

• Revisão 1, 05/09/2024 (Levana Chen)
  • Descrição inicial da extensão
• Revisão 2, 01/04/2025 (Kenny Vercaemer)
  • Regiões de confiança de rosto adicionadas
• Revisão 3, 04/06/2025 (Levana Chen)
  • Adicionamos um novo código de erro.

OpenXR™ e o logotipo OpenXR são marcas registradas de propriedade da The Khronos Group Inc. e estão registradas como marcas comerciais na China, na União Europeia, no Japão e no Reino Unido.