Crea un'app Android in realtà aumentata con Google ARCore

Contenuto

Importazione di modelli 3D, con il plug-in Sceneform
Installazione del plug-in Sceneform
Sceneform UX e Java 8: aggiornamento delle dipendenze del progetto
Richiesta di autorizzazioni con ArFragment
AR richiesto o facoltativo?
1. AR richiesto
2. AR Opzionale
Aggiungi ArFragment al tuo layout
Download di modelli 3D, utilizzando Poly di Google
Importazione di modelli 3D in Android Studio
Visualizza il tuo modello 3D
1. Creare una variabile membro ArFragment
2. Costruire un ModelRenderable
3. Rispondi all'input dell'utente
4. Ancorare il modello
5. Aggiungi supporto per spostamento, ridimensionamento e rotazione
MainActivity completata
Test dell'app per la realtà aumentata di Google ARCore
Test di ARCore su un dispositivo virtuale Android
Avvolgendo

Importazione di modelli 3D, con il plug-in Sceneform

Di solito, lavorare con modelli 3D richiede conoscenze specialistiche, ma con il rilascio del plug-in Sceneform Google ha reso possibile il rendering di modelli 3D usando Java e senza dover imparare OpenGL.

Il plug-in Sceneform fornisce un'API di alto livello che è possibile utilizzare per creare rendering renderizzabili da widget, forme o materiali Android standard o da risorse 3D, come file .OBJ o .FBX.

Nel nostro progetto, utilizzeremo il plug-in Sceneform per importare un file .OBJ in Android Studio. Ogni volta che importi un file usando Sceneform, questo plugin automaticamente:

Converti il file di risorse in un file .sfb. Questo è un formato binario di Sceneform ottimizzato per il runtime (.sfb) che viene aggiunto al tuo APK e quindi caricato in fase di runtime. Useremo questo file .sfb per creare un rendering, che consiste in mesh, materiali e trame e può essere posizionato ovunque all'interno della scena aumentata.
Genera un file .sfa. Questo è un file di descrizione delle risorse, che è un file di testo contenente una descrizione leggibile dall'uomo del file .sfb. A seconda del modello, potresti essere in grado di cambiarne l'aspetto modificando il testo all'interno del file .sfa.

Basta essere consapevoli del fatto che al momento della scrittura, il plug-in Sceneform era ancora in beta, quindi potresti riscontrare bug, errori o altri comportamenti strani quando si utilizza questo plug-in.

Installazione del plug-in Sceneform

Il plug-in Sceneform richiede Android Studio 3.1 o versioni successive. Se non sei sicuro di quale versione di Android Studio stai utilizzando, seleziona "Android Studio> Informazioni su Android Studio" dalla barra degli strumenti. Il popup successivo contiene alcune informazioni di base sull'installazione di Android Studio, incluso il numero di versione.

Per installare il plug-in Sceneform:

Se sei su un Mac, seleziona "Android Studio> Preferenze ..." dalla barra degli strumenti di Android Studio, quindi scegli "Plugin" dal menu a sinistra. Se utilizzi un PC Windows, seleziona "File> Impostazioni> Plugin> Sfoglia repository".
Cerca "Sceneform". Quando viene visualizzato "Google Sceneform Tools", seleziona "Installa".
Riavvia Android Studio quando richiesto e il plug-in sarà pronto per l'uso.

Sceneform UX e Java 8: aggiornamento delle dipendenze del progetto

Cominciamo aggiungendo le dipendenze che utilizzeremo durante questo progetto. Apri il tuo file build.gradle a livello di modulo e aggiungi la libreria Sceneform UX, che contiene l'ArFragment che useremo nel nostro layout:

dipendenze {implementazione fileTree (dir: libs, include:) implementazione androidx.appcompat: appcompat: 1.0.2 implementazione androidx.constraintlayout: limitintlayout: 1.1.3 testImplementation junit: junit: 4.12 androidTestImplementation androidx.test.ext: junit: 1.1.0 androidTestImplementation androidx.test.espresso: espresso-core: 3.1.1 // Sceneform UX fornisce risorse UX, tra cui ArFragment // implementazione "com.google.ar.sceneform.ux: sceneform-ux: 1.7.0" implementazione "com. android.support:appcompat-v7:28.0.0 "}

Sceneform utilizza costrutti di linguaggio da Java 8, quindi dovremo anche aggiornare la compatibilità dei sorgenti del nostro progetto e la compatibilità dei target con Java 8:

compileOptions {sourceCompatibility JavaVersion.VERSION_1_8 targetCompatibility JavaVersion.VERSION_1_8}

Infine, dobbiamo applicare il plugin Sceneform:

applica plugin: com.google.ar.sceneform.plugin

Il file build.gradle completato dovrebbe essere simile al seguente:

applica plug-in: com.android.application android {compileSdkVersion 28 defaultConfig {applicationId "com.jessicathornsby.arcoredemo" minSdkVersion 23 targetSdkVersion 28 versionCodice 1 versioneName "1.0" testInstrumentationRunner.Verente_persone} JavaVersion.VERSION_1_8} buildTypes {release {minifyEnabled false proguardFiles getDefaultProguardFile (proguard-android-optim.txt), proguard-rules.pro}}} dipendenze {implementazione fileTree (dir: libs, include:) implementazione androidx.appcompat: appcompat: 1.0 .2 implementazione androidx.constraintlayout: limitintlayout: 1.1.3 testImplementation junit: junit: 4.12 androidTestImplementation androidx.test.ext: junit: 1.1.0 androidTestImplementation androidx.test.espresso: espresso-core: 3.1.1 implementazione "com.google. ar.sceneform.ux: sceneform-ux: 1.7.0 "implementazione" com.android.support:appcompat-v7:28.0.0 "} applica plugin: com.google.ar .sceneform.plugin

Richiesta di autorizzazioni con ArFragment

La nostra applicazione utilizzerà la fotocamera del dispositivo per analizzare l'ambiente circostante e posizionare i modelli 3D nel mondo reale. Prima che la nostra applicazione possa accedere alla videocamera, richiede l'autorizzazione della videocamera, quindi apri il manifest del tuo progetto e aggiungi quanto segue:

Android 6.0 offre agli utenti la possibilità di concedere, negare e revocare le autorizzazioni in base alle autorizzazioni. Sebbene ciò abbia migliorato l'esperienza dell'utente, gli sviluppatori Android devono ora richiedere manualmente le autorizzazioni in fase di esecuzione e gestire la risposta dell'utente. La buona notizia è che quando si lavora su Google ARCore, viene implementato il processo di richiesta dell'autorizzazione della fotocamera e gestione della risposta dell'utente automaticamente.

Il componente ArFragment verifica automaticamente se l'app dispone dell'autorizzazione della videocamera e quindi la richiede, se necessario, prima di creare la sessione AR. Poiché utilizzeremo ArFragment nella nostra app, non è necessario scrivere alcun codice per richiedere l'autorizzazione della fotocamera.

AR richiesto o facoltativo?

Esistono due tipi di applicazioni che utilizzano la funzionalità AR:

1. AR richiesto

Se la tua applicazione si basa su Google ARCore per offrire una buona esperienza utente, devi assicurarti che venga scaricata solo e sempre su dispositivi che supportano ARCore. Se contrassegni la tua app come "Richiesto AR", verrà visualizzata solo nel Google Play Store, se il dispositivo supporta ARCore.

Dalla nostra applicazione fa richiedere ARCore, aprire il manifest e aggiungere quanto segue:

C'è anche la possibilità che l'applicazione possa essere scaricata su un dispositivo che supporti ARCore in teoria, ma in realtà ARCore non è installato. Una volta contrassegnata la nostra app come "Richiesto AR", Google Play scaricherà e installerà automaticamente ARCore insieme alla tua app, se non è già presente sul dispositivo di destinazione.

Tieni presente che anche se l'app è Android: richiesto = "vero" lo farai ancora è necessario verificare che ARCore sia presente in fase di esecuzione, poiché esiste la possibilità che l'utente abbia disinstallato ARCore dal download dell'app o che la loro versione di ARCore non sia aggiornata.

La buona notizia è che stiamo usando ArFragment, che controlla automaticamente che ARCore sia installato e aggiornato prima della creazione ogni Sessione AR: quindi, ancora una volta, non è necessario implementare manualmente.

2. AR Opzionale

Se la tua app include funzionalità AR che sono utili ma non essenziali per offrire le sue funzionalità principali, puoi contrassegnare questa applicazione come "AR opzionale". La tua app può quindi verificare se Google ARCore è presente in fase di esecuzione e disabilitarne Funzionalità AR su dispositivi che non supportano ARCore.

Se si crea un'app "AR opzionale", ARCore lo farà non essere installato automaticamente insieme all'applicazione, anche se il dispositivo dispone di tutto l'hardware e il software necessari per supportare ARCore. L'app "AR opzionale" dovrà quindi verificare se ARCore è presente e aggiornato e scaricare l'ultima versione come e quando richiesto.

Se ARCore non è cruciale per la tua app, puoi aggiungere quanto segue al tuo manifest:

Mentre ho Manifest aperto, sto anche aggiungendo android: configChanges e android: screenOrientation, per garantire che MainActivity gestisca i cambiamenti di orientamento con grazia.

Dopo aver aggiunto tutto questo al tuo manifest, il file completato dovrebbe assomigliare a questo:

Aggiungi ArFragment al tuo layout

Userò ArFragment di ARCore, poiché gestisce automaticamente una serie di attività ARCore chiave all'inizio di ogni sessione AR. In particolare, ArFragment verifica che sul dispositivo sia installata una versione compatibile di ARCore e che l'app disponga attualmente dell'autorizzazione della videocamera.

Una volta che ArFragment ha verificato che il dispositivo può supportare le funzionalità AR della tua app, crea una sessione ARCScoreView ARCore e l'esperienza AR della tua app è pronta per iniziare!

Puoi aggiungere il frammento di ArFragment a un file di layout, proprio come un normale frammento di Android, quindi apri il tuo file activity_main.xml e aggiungi un componente "com.google.ar.sceneform.ux.ArFragment".

Download di modelli 3D, utilizzando Poly di Google

Esistono diversi modi per creare rendering, ma in questo articolo utilizzeremo un file di risorse 3D.

Sceneform supporta risorse 3D nei formati .OBJ, .glTF e .FBX, con o senza animazioni. Ci sono molti posti in cui puoi acquisire modelli 3D in uno di questi formati supportati, ma in questo tutorial userò un file .OBJ, scaricato dal repository Poly di Google.

Vai sul sito Web Poly e scarica la risorsa che desideri utilizzare, nel formato .OBJ (sto usando questo modello T-Rex).

Decomprimi la cartella, che dovrebbe contenere il file degli asset di origine del tuo modello (.OBJ, .FBX o .glTF). A seconda del modello, questa cartella può contenere anche alcune dipendenze del modello, come i file nei formati .mtl, .bin, .png o .jpeg.

Importazione di modelli 3D in Android Studio

Una volta che hai la tua risorsa, devi importarla in Android Studio usando il plug-in Sceneform. Questo è un processo in più passaggi che richiede di:

Crea una cartella "sampledata". Sampledata è un nuovo tipo di cartella per i dati di esempio in fase di progettazione che non saranno inclusi nel tuo APK, ma saranno disponibili nell'editor di Android Studio.
Trascina e rilascia il file di risorse .OBJ originale nella cartella "sampledata".
Esegui l'importazione e la conversione di Sceneform sul file .OBJ, che genererà i file .sfa e .sfb.

Sebbene possa sembrare più semplice, non fare trascina e rilascia il file .OBJ direttamente nella directory "res" del tuo progetto, in quanto ciò comporterebbe il modello da includere inutilmente nel tuo APK.

I progetti Android Studio non contengono una cartella "sampledata" per impostazione predefinita, quindi dovrai crearne una manualmente:

Fai clic tenendo premuto il tasto Ctrl sulla cartella "app" del tuo progetto.
Seleziona "Nuovo> Directory dei dati di esempio" e crea una cartella denominata "sampledata".
Passare ai file del modello 3D scaricati in precedenza. Trova il file di risorse di origine (.OBJ, .FBX o .glTF), quindi trascinalo nella directory "sampledata".
Verifica se il tuo modello ha dipendenze (come file nei formati .mtl, .bin, .png o .jpeg). Se trovi uno di questi file, trascinali e rilasciali nella cartella "sampledata".
In Android Studio, fai clic tenendo premuto il tasto Ctrl sul file sorgente del modello 3D (.OBJ, .FBX o .glTF), quindi seleziona "Importa asset scena".

La finestra successiva mostra alcune informazioni sui file che Sceneform sta per generare, incluso dove verrà archiviato il file .sfa risultante nel progetto; Userò la directory "raw".
Quando sei soddisfatto delle informazioni che hai inserito, fai clic su "Fine".

Questa importazione apporta alcune modifiche al tuo progetto. Se apri il tuo file build.gradle, vedrai che il plugin Sceneform è stato aggiunto come dipendenza del progetto:

dipendenze {classpath com.android.tools.build:gradle:3.5.0-alpha06 classpath com.google.ar.sceneform: plugin: 1.7.0 // NOTA: non inserire qui le dipendenze dell'applicazione; appartengono // nei singoli file build.gradle del modulo}}

Apri il tuo file build.gradle a livello di modulo e troverai una nuova voce sceneform.asset () per il tuo modello 3D importato:

applicare il plug-in: com.google.ar.sceneform.plugin // Il "Percorso risorse sorgente" specificato durante l'importazione // sceneform.asset (sampledata / dinosaur.obj, // Il "Percorso materiale" specificato durante l'importazione // Predefinito , // Il "Percorso di output .sfa" specificato durante l'importazione // sampledata / dinosaur.sfa, // Il "Percorso di output .sfb" specificato durante l'importazione // src / main / assets / dinosaur)

Se dai un'occhiata alle cartelle "sampledata" e "raw", vedrai che contengono rispettivamente nuovi file .sfa e .sfb.

Puoi visualizzare l'anteprima del file .sfa nel nuovo Sceneform Viewer di Android Studio:

Seleziona "Visualizza> Strumenti Windows> Visualizzatore" dalla barra dei menu di Android Studio.
Nel menu a sinistra, seleziona il tuo file .sfa. Il tuo modello 3D ora dovrebbe apparire nella finestra del Visualizzatore.

Visualizza il tuo modello 3D

Il nostro prossimo compito è creare una sessione AR che comprenda l'ambiente circostante e che consenta all'utente di posizionare modelli 3D in una scena aumentata.

Ciò richiede che effettuiamo le seguenti operazioni:

1. Creare una variabile membro ArFragment

ArFragment esegue gran parte del lavoro pesante che comporta la creazione di una sessione AR, quindi faremo riferimento a questo frammento durante la nostra classe MainActivity.

Nel frammento seguente, sto creando una variabile membro per ArFragment e quindi inizializzandola nel metodo onCreate ():

ArFragment privato arCoreFragment; @Override protetto void onCreate (Bundle savedInstanceState) {super.onCreate (savedInstanceState); ... ... ...} setContentView (R.layout.activity_main); arCoreFragment = (ArFragment) // Trova il frammento, usando il gestore dei frammenti // getSupportFragmentManager (). findFragmentById (R.id.main_fragment);

2. Costruire un ModelRenderable

Ora dobbiamo trasformare il nostro file .sfb in un ModelRenderable, che alla fine renderà il nostro oggetto 3D.

Qui sto creando un ModelRenderable dal file res / raw / dinosaur .sfb del mio progetto:

privato ModelRenderable dinoRenderable; ... ... ... ModelRenderable.builder () .setSource (this, R.raw.dinosaur) .build () .thenAccept (renderable -> dinoRenderable = renderable) .exceptionally (lanciabile -> {Log.e ( TAG, "Impossibile caricare renderable"); return null;}); }

3. Rispondi all'input dell'utente

ArFragment ha il supporto integrato per i gesti di tocco, trascinamento, pizzico e rotazione.

Nella nostra app, l'utente aggiungerà un modello 3D a un piano ARCore, dando a quel piano un tocco.

Per fornire questa funzionalità, dobbiamo registrare un callback che verrà invocato ogni volta che viene toccato un aereo:

arCoreFragment.setOnTapArPlaneListener ((HitResult hitResult, Plane plane, MotionEvent motionEvent) -> {if (dinoRenderable == null) {return;}

4. Ancorare il modello

In questo passaggio, recupereremo un ArSceneView e lo collegheremo a un AnchorNode, che fungerà da nodo principale della scena.

ArSceneView è responsabile dell'esecuzione di alcune importanti attività ARCore, tra cui il rendering delle immagini della videocamera del dispositivo e la visualizzazione di un'animazione Sceneform UX che dimostra come l'utente deve tenere e spostare il proprio dispositivo per iniziare l'esperienza AR. ArSceneView evidenzierà anche tutti i piani che rileva, pronti per l'utente di posizionare i propri modelli 3D all'interno della scena.

Al componente ARSceneView è associata una scena, che è una struttura di dati padre-figlio contenente tutti i nodi che devono essere sottoposti a rendering.

Inizieremo creando un nodo di tipo AnchorNode, che fungerà da nodo principale del nostro ArSceneView.

Tutti i nodi di ancoraggio rimangono nella stessa posizione nel mondo reale, quindi creando un nodo di ancoraggio ci assicuriamo che i nostri modelli 3D rimangano fissi all'interno della scena aumentata.

Creiamo il nostro nodo di ancoraggio:

AnchorNode anchorNode = new AnchorNode (anchor);

È quindi possibile recuperare un ArSceneView utilizzando getArSceneView () e collegarlo a AnchorNode:

anchorNode.setParent (arCoreFragment.getArSceneView () getScene ().);

5. Aggiungi supporto per spostamento, ridimensionamento e rotazione

Successivamente, creerò un nodo di tipo TransformableNode. TransformableNode è responsabile dello spostamento, del ridimensionamento e della rotazione dei nodi, in base ai gesti dell'utente.

Dopo aver creato un TransformableNode, puoi collegarlo a Renderable, che darà al modello la possibilità di ridimensionare e spostare, in base all'interazione dell'utente. Infine, è necessario connettere TransformableNode a AnchorNode, in una relazione padre-figlio che garantisca TransformableNode e Il rendering rimane fisso nella scena aumentata.

TransformableNode transformableNode = new TransformableNode (arCoreFragment.getTransformationSystem ()); // Collega transformableNode a anchorNode // transformableNode.setParent (anchorNode); transformableNode.setRenderable (dinoRenderable); // Seleziona il nodo // transformableNode.select (); }); }

MainActivity completata

Dopo aver eseguito tutto quanto sopra, MainActivity dovrebbe assomigliare a questo:

import android.app.Activity; import android.app.ActivityManager; import androidx.appcompat.app.AppCompatActivity; import android.content.Context; import android.net.Uri; import android.os.Build; import android.os.Build.VERSION_CODES; import android.os.Bundle; import android.util.Log; import android.view.MotionEvent; import androidx.annotation.RequiresApi; import com.google.ar.core.Anchor; import com.google.ar.core.HitResult; import com.google.ar.core.Plane; import com.google.ar.sceneform.AnchorNode; import com.google.ar.sceneform.rendering.ModelRenderable; import com.google.ar.sceneform.ux.ArFragment; import com.google.ar.sceneform.ux.TransformableNode; classe pubblica MainActivity estende AppCompatActivity {stringa statica privata finale TAG = MainActivity.class.getSimpleName (); doppio finale statico privato MIN_OPENGL_VERSION = 3.0; // Crea una variabile membro per ModelRenderable // private ModelRenderable dinoRenderable; // Crea una variabile membro per ArFragment // private ArFragment arCoreFragment; @RequiresApi (api = VERSION_CODES.N) @Override protetto void onCreate (Bundle savedInstanceState) {super.onCreate (savedInstanceState); if (! checkDevice ((this))) {return; } setContentView (R.layout.activity_main); arCoreFragment = (ArFragment) // Trova il frammento, usando Gestione frammenti // getSupportFragmentManager (). findFragmentById (R.id.main_fragment); if (Build.VERSION.SDK_INT> = VERSION_CODES.N) {// Build the ModelRenderable // ModelRenderable.builder () .setSource (this, R.raw.dinosaur) .build () .thenAccept (renderable -> dinoRenderable = renderable ) .exceptionally (// Se si verifica un errore ... // gettabile -> {//... quindi stampa quanto segue su Logcat // Log.e (TAG, "Impossibile caricare renderable"); return null;} ); } // Ascolta eventi onTap // arCoreFragment.setOnTapArPlaneListener ((HitResult hitResult, Plane plane, MotionEvent motionEvent) -> {if (dinoRenderable == null) {return;} Anchor anchor = hitResult.createAnchor (); // Build a nodo di tipo AnchorNode // AnchorNode anchorNode = new AnchorNode (anchor); // Collega AnchorNode alla scena // anchorNode.setParent (arCoreFragment.getArSceneView (). getScene ()); // Crea un nodo di tipo TransformableNode // TransformableNode transformableNode = new TransformableNode (arCoreFragment.getTransformationSystem ()); // Collega TransformableNode a AnchorNode // transformableNode.setParent (anchorNode); // Collega Renderable // transformableNode.setRenderable (dinoRenderable); // Imposta il nodo / / transformableNode.select ();}); } public boolean checkDevice pubblico (attività di attività finale) {// Se il dispositivo esegue Android Marshmallow o precedente ... // if (Build.VERSION.SDK_INT <VERSION_CODES.N) {//... quindi stampa quanto segue su Logcat // Log.e (TAG, "Sceneform richiede Android N o versioni successive"); activity.finish (); restituire false; } String openGlVersionString = ((ActivityManager) activity.getSystemService (Context.ACTIVITY_SERVICE)) .getDeviceConfigurationInfo () // Controlla la versione di OpenGL ES // .getGlEsVersion (); // Se il dispositivo esegue qualcosa di meno di OpenGL ES 3.0 ... // if (Double.parseDouble (openGlVersionString) <MIN_OPENGL_VERSION) {//... quindi stampa quanto segue su Logcat // Log.e (TAG, " Richiede OpenGL ES 3.0 o versioni successive "); activity.finish (); restituire false; } return true; }}

Puoi scaricare il progetto completato da GitHub.

Test dell'app per la realtà aumentata di Google ARCore

Ora sei pronto per testare la tua applicazione su un dispositivo Android fisico supportato. Se non possiedi un dispositivo che supporta ARCore, è possibile testare la tua app AR nell'emulatore Android (con un po 'di configurazione aggiuntiva, che tratteremo nella sezione successiva).

Per testare il tuo progetto su a fisico Dispositivo Android:

Installa l'applicazione sul dispositivo di destinazione.
Quando richiesto, concedi all'applicazione l'accesso alla fotocamera del tuo dispositivo.
Se ti viene richiesto di installare o aggiornare l'app ARCore, tocca “Continua” e quindi completa la finestra di dialogo per assicurarti di eseguire la versione più recente e più grande di ARCore.
Ora dovresti vedere una vista della telecamera, completa di un'animazione di una mano che regge un dispositivo. Puntare la fotocamera su una superficie piana e spostare il dispositivo con un movimento circolare, come dimostrato dall'animazione. Dopo alcuni istanti, dovrebbe apparire una serie di punti che indicano che è stato rilevato un piano.

Una volta che sei soddisfatto della posizione di questi punti, dai loro un tocco: il tuo modello 3D ora dovrebbe apparire sul piano scelto!

Prova a spostarti fisicamente attorno al modello; a seconda di ciò che ti circonda, potresti essere in grado di compiere i 360 gradi al massimo. Dovresti anche verificare che l'oggetto stia proiettando un'ombra coerente con le fonti di luce del mondo reale.

Test di ARCore su un dispositivo virtuale Android

Per testare le tue app ARCore in un dispositivo virtuale Android (AVD), devi disporre dell'emulatore Android versione 27.2.9 o successiva. È inoltre necessario accedere a Google Play Store sul proprio AVD e abilitare OpenGL ES 3.0 o versione successiva.

Per verificare se OpenGL ES 3.0 o versione successiva è attualmente abilitato sul tuo AVD:

Avvia il tuo AVD, come di consueto.
Apri una nuova finestra Terminale (Mac) o un Prompt dei comandi (Windows).
Cambia directory ("cd") in modo che il prompt dei comandi / terminali indichi la posizione del programma "adb" del tuo SDK Android, ad esempio il mio comando è simile al seguente:

Cd / Users / jessicathornsby / Library / Android / sdk / platform-tools

Premi il tasto "Invio" sulla tastiera.
Copia / incolla il comando successivo nel Terminale, quindi premi il tasto "Invio":

./adb logcat | grep eglMakeCurrent

Se il Terminale restituisce "ver 3 0" o versione successiva, OpenGL ES è configurato correttamente. Se il prompt dei comandi o dei terminali visualizza qualcosa di precedente alla 3.0, dovrai abilitare OpenGL ES 3.0:

Torna al tuo AVD.
Trova la striscia di pulsanti "Controllo esteso" che galleggiano accanto all'emulatore Android, quindi seleziona "Impostazioni> Avanzate".
Passare a "Livello API OpenGL ES> Renderer massimo (fino a OpenGL ES 3.1)."
Riavvia l'emulatore.

Nella finestra del prompt dei comandi / dei terminali, copia / incolla il seguente comando e premi il tasto "Invio"

./adb logcat | grep eglMakeCurrent

Ora dovresti ottenere un risultato di "ver 3 0" o superiore, il che significa che OpenGL ES è configurato correttamente.

Infine, assicurati che sul tuo AVD sia in esecuzione l'ultima versione di ARCore:

Vai alla pagina GitHub di ARCore e scarica l'ultima versione di ARCore per l'emulatore. Ad esempio, al momento della stesura della versione più recente era "ARCore_1.7.0.x86_for_emulator.apk"
Trascina e rilascia l'APK sul tuo AVD in esecuzione.

Per testare il tuo progetto su un AVD, installa l'applicazione e concedi l'accesso alla "videocamera" dell'AVD quando richiesto.

Ora dovresti vedere una telecamera di una stanza simulata. Per testare la tua applicazione, spostati in questo spazio virtuale, trova una superficie piana simulata e fai clic per posizionare un modello su questa superficie.

Puoi spostare la videocamera virtuale nella stanza virtuale, tenendo premuti i tasti “Opzione” (macOS) o “Alt” (Linux o Windows), quindi usando una delle seguenti scorciatoie da tastiera:

Sposta a sinistra o a destra. Premi A o D.
Sposta in basso o in alto. Premi Q o E.
Vai avanti o indietro. Premi W o S.

Puoi anche "muoverti" nella scena virtuale, premendo "Opzione" o "Alt" e quindi usando il mouse. All'inizio può sembrare un po 'goffo, ma con la pratica dovresti essere in grado di esplorare con successo lo spazio virtuale. Una volta trovato un piano simulato, fai clic sui punti bianchi per posizionare il modello 3D su questa superficie.

Avvolgendo

In questo articolo, abbiamo creato una semplice app di realtà aumentata, utilizzando ARCore e il plug-in Sceneform.

Se decidi di utilizzare Google ARCore nei tuoi progetti, assicurati di condividere le tue creazioni nei commenti qui sotto!