Estensione OpenXR XR_ANDROID_face_tracking

Stringa del nome

XR_ANDROID_face_tracking

Tipo di estensione

Estensione dell'istanza

Numero di interno registrato

459

Revisione

3

Dipendenze da estensioni e versioni

OpenXR 1.0

Data ultima modifica

2025-06-04

Stato IP

Nessuna rivendicazione di proprietà intellettuale nota.

Collaboratori

Spencer Quin, Google

Jared Finder, Google

Levana Chen, Google

Panoramica

Questa estensione consente alle applicazioni di ottenere i pesi delle forme di fusione e di eseguire il rendering delle espressioni facciali nelle esperienze XR.

Questa estensione ha lo scopo di fornire le informazioni necessarie per creare avatar realistici e rappresentazioni espressive degli utenti nello spazio virtuale. L'applicazione può controllare l'attivazione della calibrazione facciale prima di ottenere i pesi delle forme di fusione.

Face Tracker

Un tracker del volto è un dispositivo di rilevamento che traccia l'espressione facciale tramite flussi di immagini rivolti all'utente e calibrazione della videocamera. Lo scopo principale di questa estensione è mappare le espressioni facciali dell'utente ai suoi avatar in una scena virtuale.

I dati di monitoraggio del volto sono informazioni personali sensibili e sono strettamente collegati alla privacy e all'integrità personali. È vivamente consigliato che le applicazioni che archiviano o trasferiscono dati di monitoraggio del volto chiedano sempre all'utente un'accettazione attiva e specifica per farlo.

• Le app riceveranno XR_ERROR_PERMISSION_INSUFFICIENT durante la creazione di un tracker del volto attivo finché l'app non avrà ottenuto l'accesso al tracker del volto.
• Quando ottieni gli stati del volto utilizzando xrGetFaceStateANDROID, XrFaceStateANDROID::isValid non restituirà XR_TRUE a meno che l'accesso all'applicazione non sia stato consentito

Ispezionare la funzionalità del sistema

La struttura XrSystemFaceTrackingPropertiesANDROID è definita come:

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

Descrizioni dei membri

• type è l'XrStructureType di questa struttura.
• next è NULL o un puntatore alla struttura successiva in una catena di strutture.
• supportsFaceTracking è un XrBool32 che indica se il sistema attuale supporta il rilevamento del volto.

Un'applicazione può verificare se il sistema è in grado di eseguire il monitoraggio del volto estendendo XrSystemProperties con la struttura XrSystemFaceTrackingPropertiesANDROID quando chiama xrGetSystemProperties.

Se e solo se un runtime restituisce XR_FALSE per supportsFaceTracking, il runtime deve restituire XR_ERROR_FEATURE_UNSUPPORTED da xrCreateFaceTrackerANDROID.

Creare un handle per il tracker facciale

XR_DEFINE_HANDLE(XrFaceTrackerANDROID)

L'handle XrFaceTrackerANDROID rappresenta un tracker del volto per il monitoraggio del volto.

Questo handle può essere utilizzato per accedere ai dati di tracciamento del volto utilizzando altre funzioni in questa estensione.

La funzione xrCreateFaceTrackerANDROID è definita come:

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

Descrizioni dei parametri

• session è un handle XrSession in cui il tracker del volto sarà attivo.
• createInfo è XrFaceTrackerCreateInfoANDROID utilizzato per specificare il tracker del volto.
• faceTracker è l'handle XrFaceTrackerANDROID restituito.

Un'applicazione può creare un handle XrFaceTrackerANDROID utilizzando la funzione xrCreateFaceTrackerANDROID.

Se il sistema non supporta il rilevamento del volto, xrCreateFaceTrackerANDROID restituirà XR_ERROR_FEATURE_UNSUPPORTED.

Utilizzo valido (implicito)

• L'estensione XR_ANDROID_face_tracking deve essere attivata prima di chiamare xrCreateFaceTrackerANDROID
• session deve essere un handle XrSession valido
• createInfo deve essere un puntatore a una struttura XrFaceTrackerCreateInfoANDROID valida
• faceTracker deve essere un puntatore a un handle XrFaceTrackerANDROID

Codici di ritorno

Operazione riuscita

• XR_SUCCESS
• XR_SESSION_LOSS_PENDING

Errore

• 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 struttura XrFaceTrackerCreateInfoANDROID è descritta nel seguente modo:

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

Descrizioni dei membri

• type è l'XrStructureType di questa struttura.
• next è NULL o un puntatore alla struttura successiva in una catena di strutture. Nessuna struttura di questo tipo è definita in OpenXR di base o in questa estensione.

La struttura XrFaceTrackerCreateInfoANDROID descrive le informazioni per creare un handle XrFaceTrackerANDROID.

Utilizzo valido (implicito)

• L'estensione XR_ANDROID_face_tracking deve essere abilitata prima di utilizzare XrFaceTrackerCreateInfoANDROID
• type deve essere XR_TYPE_FACE_TRACKER_CREATE_INFO_ANDROID
• next deve essere NULL o un puntatore valido alla struttura successiva in una catena di strutture

La funzione xrDestroyFaceTrackerANDROID è definita come:

XrResult xrDestroyFaceTrackerANDROID(
    XrFaceTrackerANDROID                        faceTracker);

Descrizioni dei parametri

• faceTracker è un XrFaceTrackerANDROID creato in precedenza da xrCreateFaceTrackerANDROID.

La funzione xrDestroyFaceTrackerANDROID rilascia faceTracker e le risorse sottostanti al termine dell'esperienza di rilevamento del volto.

Utilizzo valido (implicito)

• L'estensione XR_ANDROID_face_tracking deve essere attivata prima di chiamare xrDestroyFaceTrackerANDROID
• faceTracker deve essere un handle XrFaceTrackerANDROID valido

Thread Safety

• L'accesso a faceTracker e a tutti gli handle secondari deve essere sincronizzato esternamente

Codici di ritorno

Operazione riuscita

• XR_SUCCESS

Errore

• XR_ERROR_FUNCTION_UNSUPPORTED
• XR_ERROR_HANDLE_INVALID

Controllare la calibrazione del volto

La funzione xrGetFaceCalibrationStateANDROID è definita come:

XrResult xrGetFaceCalibrationStateANDROID(
    XrFaceTrackerANDROID                        faceTracker,
    XrBool32*                                   faceIsCalibratedOutput);

Descrizioni dei parametri

• faceTracker è un XrFaceTrackerANDROID creato in precedenza da xrCreateFaceTrackerANDROID.
• faceIsCalibratedOutput indica se il tracker del volto è stato calibrato o meno.

Un'applicazione può controllare lo stato di calibrazione del volto utilizzando la funzione xrGetFaceCalibrationStateANDROID.

Quando il servizio di monitoraggio è ancora in fase di inizializzazione, il runtime potrebbe restituire XR_ERROR_SERVICE_NOT_READY_ANDROID da xrGetFaceCalibrationStateANDROID per indicare che l'applicazione può riprovare in un secondo momento.

Se il sistema non supporta la calibrazione del volto, xrGetFaceCalibrationStateANDROID restituirà XR_ERROR_FEATURE_UNSUPPORTED. In caso contrario, faceIsCalibratedOutput potrebbe essere impostato su XR_TRUE per riflettere lo stato di calibrazione del volto.

Utilizzo valido (implicito)

• L'estensione XR_ANDROID_face_tracking deve essere attivata prima di chiamare xrGetFaceCalibrationStateANDROID
• faceTracker deve essere un handle XrFaceTrackerANDROID valido
• faceIsCalibratedOutput deve essere un puntatore a un valore XrBool32

Codici di ritorno

Operazione riuscita

• XR_SUCCESS
• XR_SESSION_LOSS_PENDING

Errore

• 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

Ottenere espressioni facciali

La funzione xrGetFaceStateANDROID restituisce le forme di fusione delle espressioni facciali in un determinato momento.

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

Descrizioni dei parametri

• faceTracker è un XrFaceTrackerANDROID creato in precedenza da xrCreateFaceTrackerANDROID.
• getInfo è un puntatore a XrFaceStateGetInfoANDROID che descrive le informazioni per ottenere le espressioni facciali.
• faceStateOutput è un puntatore a XrFaceStateANDROID che riceve lo stato di tracciamento del volto e le espressioni facciali restituiti.

Utilizzo valido (implicito)

• L'estensione XR_ANDROID_face_tracking deve essere attivata prima di chiamare xrGetFaceStateANDROID
• faceTracker deve essere un handle XrFaceTrackerANDROID valido
• getInfo deve essere un puntatore a una struttura XrFaceStateGetInfoANDROID valida
• faceStateOutput deve essere un puntatore a una struttura XrFaceStateANDROID

Codici di ritorno

Operazione riuscita

• XR_SUCCESS
• XR_SESSION_LOSS_PENDING

Errore

• 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 struttura XrFaceStateGetInfoANDROID descrive le informazioni per ottenere le espressioni facciali.

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

Descrizioni dei membri

• type è l'XrStructureType di questa struttura.
• next è NULL o un puntatore alla struttura successiva in una catena di strutture. Nessuna struttura di questo tipo è definita in OpenXR di base o in questa estensione.
• time è un XrTime in cui vengono richieste le espressioni facciali.

Le applicazioni devono richiedere un tempo pari al tempo di visualizzazione previsto per il frame sottoposto a rendering.

Utilizzo valido (implicito)

• L'estensione XR_ANDROID_face_tracking deve essere attivata prima di utilizzare XrFaceStateGetInfoANDROID
• type deve essere XR_TYPE_FACE_STATE_GET_INFO_ANDROID
• next deve essere NULL o un puntatore valido alla struttura successiva in una catena di strutture

La struttura XrFaceStateANDROID restituisce lo stato del tracciamento facciale e le espressioni facciali.

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;

Descrizioni dei membri

• type è l'XrStructureType di questa struttura.
• next è NULL o un puntatore alla struttura successiva in una catena di strutture. Nessuna struttura di questo tipo è definita in OpenXR di base o in questa estensione.
• parametersCapacityInput è un uint32_t che descrive la capacità dell'array parameters o 0 per indicare una richiesta di recupero della capacità richiesta.
• parametersCountOutput è un uint32_t che descrive il numero di parameters o la capacità richiesta nel caso in cui parametersCapacityInput sia insufficiente.
• parameters è un puntatore a un array di float allocato dall'applicazione che verrà riempito con i pesi delle forme di fusione delle espressioni facciali.
• faceTrackingState è il XrFaceTrackingStateANDROID dello stato di validità del monitoraggio del volto.
• sampleTime è un'ora XrTime in cui le espressioni restituite vengono monitorate o estrapolate. È uguale all'ora in cui sono stati richiesti i pesi dell'espressione se l'estrapolazione al momento è andata a buon fine.
• isValid indica se i dati sono validi anche se non provengono dal frame corrente.
• regionConfidencesCapacityInput è un uint32_t che descrive la capacità dell'array regionConfidences o 0 per indicare una richiesta di recupero della capacità richiesta.
• regionConfidencesCountOutput è un uint32_t che descrive il numero di regionConfidences o la capacità richiesta nel caso in cui regionConfidencesCapacityInput sia insufficiente.
• regionConfidences è un puntatore a un array di float allocato dall'applicazione che verrà compilato con i valori di confidenza per ogni regione del viso.
• Consulta la sezione Parametri delle dimensioni del buffer per una descrizione dettagliata del recupero delle dimensioni richieste di parameters e regionConfidences.

L'applicazione può impostare parametersCapacityInput su XR_FACE_PARAMETER_COUNT_ANDROID per ottenere espressioni facciali indicizzate da XrFaceParameterIndicesANDROID.

I parameters restituiti rappresentano i pesi delle forme di fusione delle espressioni facciali attuali.

Gli aggiornamenti dell'array parameters verranno ordinati in modo che l'applicazione possa indicizzare gli elementi utilizzando l'enum dell'espressione facciale corrispondente (ad es. XrFaceParameterIndicesANDROID).

Utilizzo valido (implicito)

• L'estensione XR_ANDROID_face_tracking deve essere attivata prima di utilizzare XrFaceStateANDROID
• type deve essere XR_TYPE_FACE_STATE_ANDROID
• next deve essere NULL o un puntatore valido alla struttura successiva in una catena di strutture
• Se parametersCapacityInput non è 0, parameters, must deve essere un puntatore a un array di valori parametersCapacityInput float
• Se regionConfidencesCapacityInput non è 0, regionConfidences, must deve essere un puntatore a un array di valori regionConfidencesCapacityInput float
• faceTrackingState deve essere un valore XrFaceTrackingStateANDROID valido

L'enumerazione XrFaceTrackingStateANDROID identifica i diversi stati del rilevatore di volti.

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;

Gli enum hanno i seguenti significati:

Regioni di confidenza

L'estensione XR_ANDROID_face_tracking fornisce anche valori di confidenza per tre regioni del viso: occhio sinistro, occhio destro e parte inferiore del viso. Questi valori, che vanno da 0 (nessuna confidenza) a 1 (confidenza massima), indicano l'accuratezza del tracciamento del volto per ogni regione.

Puoi utilizzare questi valori di confidenza per disattivare progressivamente le blend shape o applicare filtri visivi (come la sfocatura) alla regione del viso corrispondente. Per un controllo di base on/off, ti consigliamo di utilizzare una soglia di 0,3 per disattivare completamente le blend shape nella regione del viso corrispondente.

L'area "parte inferiore del viso" rappresenta tutto ciò che si trova sotto gli occhi, inclusi bocca, mento, guancia e naso. La regione degli occhi include gli occhi e la zona delle sopracciglia.

La tabella seguente descrive le blend shape associate a ciascuna regione di confidenza:

Convenzioni delle forme di fusione

Questa estensione definisce 68 blend shape tramite XR_FACE_PARAMETER_COUNT_ANDROID, per il formato G-Nome ridotto. Ogni parametro in questa enumerazione è un indice in un array di blend shape i cui valori sono di tipo float e il runtime normalizza a 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;

Indice	Nome	Immagine di riferimento
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	LINGUA_FUORI
64	TONGUE_LEFT
65	LINGUA_DESTRA
66	LINGUA_SU
67	LINGUA_GIÙ

Codice di esempio per il rilevamento del volto

Il seguente codice di esempio mostra come ottenere tutti i pesi per le forme di fusione delle espressioni facciali.

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

Nuovi tipi di oggetti

• XrFaceTrackerANDROID

Nuove costanti enum

• XR_FACE_PARAMETER_COUNT_ANDROID

L'enumerazione XrObjectType viene estesa con:

• XR_OBJECT_TYPE_FACE_TRACKER_ANDROID

L'enumerazione XrStructureType è estesa con:

• 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

Nuovi enum

• XrFaceParameterIndicesANDROID
• XrFaceTrackingStateANDROID

Nuove strutture

• XrFaceTrackerCreateInfoANDROID
• XrFaceStateGetInfoANDROID
• XrFaceStateANDROID
• XrSystemFaceTrackingPropertiesANDROID

Nuove funzioni

• xrCreateFaceTrackerANDROID
• xrDestroyFaceTrackerANDROID
• xrGetFaceStateANDROID
• xrGetFaceCalibrationStateANDROID

Problemi

Cronologia delle versioni

• Revisione 1, 05/09/2024 (Levana Chen)
  • Descrizione iniziale dell'estensione
• Revisione 2, 01/04/2025 (Kenny Vercaemer)
  • Aggiunte regioni di confidenza del volto
• Revisione 3, 04/06/2025 (Levana Chen)
  • È stato aggiunto un nuovo codice di errore.

OpenXR™ e il logo OpenXR sono marchi di proprietà di The Khronos Group Inc. e sono registrati come marchi in Cina, nell'Unione Europea, in Giappone e nel Regno Unito.