Construire une application Android de réalité augmentée avec Google ARCore

Contenu

Importation de modèles 3D avec le plugin Sceneform
Installer le plugin Sceneform
Sceneform UX et Java 8: mise à jour des dépendances de votre projet
Demander des autorisations avec ArFragment
AR requis ou facultatif?
1. AR requis
2. AR facultatif
Ajouter ArFragment à votre mise en page
Téléchargement de modèles 3D à l’aide du logiciel Poly
Importation de modèles 3D dans Android Studio
Affichez votre modèle 3D
1. Créer une variable membre ArFragment
2. Construire un ModelRenderable
3. Répondre aux commentaires de l'utilisateur
4. Ancrez votre modèle
5. Ajouter un support pour le déplacement, la mise à l'échelle et la rotation
La MainActivity terminée
Test de votre application de réalité augmentée Google ARCore
Test d'ARCore sur un périphérique virtuel Android
Emballer

Importation de modèles 3D avec le plugin Sceneform

Habituellement, travailler avec des modèles 3D nécessite des connaissances particulières, mais avec la publication du plugin Sceneform, Google a rendu possible le rendu de modèles 3D à l'aide de Java. sans pour autant avoir à apprendre OpenGL.

Le plug-in Sceneform fournit une API de haut niveau que vous pouvez utiliser pour créer Renderdables à partir de widgets, de formes ou de matériaux Android standard, ou à partir d'éléments 3D, tels que des fichiers .OBJ ou .FBX.

Dans notre projet, nous allons utiliser le plugin Sceneform pour importer un fichier .OBJ dans Android Studio. Chaque fois que vous importez un fichier à l'aide de Sceneform, ce plugin va automatiquement:

Convertissez le fichier d'actif en fichier .sfb. Il s'agit d'un format Sceneform Binary (.sfb) optimisé pour l'exécution qui a été ajouté à votre APK, puis chargé au moment de l'exécution. Nous allons utiliser ce fichier .sfb pour créer un rendu, composé de maillages, de matériaux et de textures, pouvant être placé n’importe où dans la scène augmentée.
Générez un fichier .sfa. Il s'agit d'un fichier de description d'actif, qui est un fichier texte contenant une description du fichier .sfb lisible par l'homme. Selon le modèle, vous pourrez peut-être modifier son apparence en modifiant le texte contenu dans le fichier .sfa.

Sachez simplement qu’au moment de la rédaction de ce dernier, le plug-in Sceneform était encore en version bêta, vous pourriez donc rencontrer des bogues, des erreurs ou tout autre comportement étrange lorsque vous utilisiez ce plug-in.

Installer le plugin Sceneform

Le plugin Sceneform nécessite Android Studio 3.1 ou supérieur. Si vous ne savez pas quelle version d'Android Studio vous utilisez, sélectionnez «Android Studio> À propos d'Android Studio» dans la barre d'outils. La fenêtre contextuelle suivante contient des informations de base sur votre installation Android Studio, y compris son numéro de version.

Pour installer le plugin Sceneform:

Si vous êtes sur un Mac, sélectionnez «Android Studio> Préférences…» dans la barre d’outils d’Android Studio, puis choisissez «Plug-ins» dans le menu de gauche. Si vous utilisez un ordinateur Windows, sélectionnez «Fichier> Paramètres> Plug-ins> Parcourir les référentiels».
Recherchez «Sceneform». Lorsque «Google Sceneform Tools» apparaît, sélectionnez «Installer».
Redémarrez Android Studio à l'invite, et votre plugin sera prêt à être utilisé.

Sceneform UX et Java 8: mise à jour des dépendances de votre projet

Commençons par ajouter les dépendances que nous utiliserons tout au long de ce projet. Ouvrez votre fichier build.gradle au niveau du module et ajoutez la bibliothèque Sceneform UX, qui contient l’ArFragment que nous allons utiliser dans notre présentation:

dependencies {implementation fileTree (dir: libs, include:) implémentation androidx.appcompat: appcompat: 1.0.2 implémentation androidx.constraintlayout: constraintlayout: 1.1.3 testImplementation junit: junit: 4.12 androidTestImplementation androidx.test.ext: version: 1.1.0 androidTestImplementation androidx.test.espresso: espresso-core: 3.1.1 // Sceneform UX fournit des ressources UX, y compris ArFragment // implémentation "com.google.ar.sceneform.ux: sceneform-ux: 1.7.0" implementation "com. android.support:appcompat-v7:28.0.0 "}

Comme Sceneform utilise des constructions de langage issues de Java 8, nous devons également mettre à jour la compatibilité source et la compatibilité cible de notre projet avec Java 8:

compileOptions {sourceCompatibility JavaVersion.VERSION_1_8 targetCompatibility JavaVersion.VERSION_1_8}

Enfin, nous devons appliquer le plugin Sceneform:

appliquer le plugin: com.google.ar.sceneform.plugin

Votre fichier build.gradle complété devrait ressembler à ceci:

appliquer le plugin: com.android.application android {compileSdkVersion 28 defaultConfig {applicationId "" com.jessicathornsby.emodem "minSdkVersion 23 target JavaVersion.VERSION_1_8} buildTypes {release {minifyEnabled false proguardFiles getDefaultProguardFile (proguard-android-optim.txt), proguard-rules.pro}}} dépendances {implementation fileTree (dir: libs, include:) implémentation: androidx.appcompat: appcompat: 1.0 .2 implémentation androidx.constraintlayout: constraintlayout: 1.1.3 testImplementation junit: junit: 4.12 androidTestImplementation androidx.test.ext: junit: 1.1.0 androidTestImplémentation androidx.test.espresso: espresso-core: 3.1.1 implementation "com.google. ar.sceneform.ux: sceneform-ux: 1.7.0 "implémentation" com.android.support:appcompat-v7:28.0.0 "} apply plugin: com.google.ar .sceneform.plugin

Demander des autorisations avec ArFragment

Notre application utilisera la caméra de l’appareil pour analyser son environnement et positionner les modèles 3D dans le monde réel. Avant que notre application puisse accéder à la caméra, celle-ci nécessite l'autorisation de la caméra. Ouvrez le manifeste de votre projet et ajoutez les éléments suivants:

Android 6.0 donne aux utilisateurs la possibilité d'accorder, de refuser et de révoquer des autorisations, autorisation par autorisation. Bien que cela ait amélioré l'expérience utilisateur, les développeurs Android doivent désormais demander manuellement les autorisations au moment de l'exécution et gérer la réponse de l'utilisateur. La bonne nouvelle est que, lorsque vous utilisez Google ARCore, le processus de demande de l'autorisation de l'appareil photo et de traitement de la réponse de l'utilisateur est mis en œuvre. automatiquement.

Le composant ArFragment vérifie automatiquement si votre application dispose de l'autorisation de la caméra, puis le demande, si nécessaire, avant de créer la session AR. Comme nous allons utiliser ArFragment dans notre application, nous n’avons pas besoin d’écrire de code pour demander l’autorisation de la caméra.

AR requis ou facultatif?

Deux types d’applications utilisent la fonctionnalité AR:

1. AR requis

Si votre application s'appuie sur Google ARCore pour offrir une bonne expérience utilisateur, vous devez vous assurer qu'elle est uniquement téléchargée sur des appareils prenant en charge ARCore. Si vous marquez votre application comme «AR Required», elle n'apparaîtra que dans Google Play Store, si l'appareil prend en charge ARCore.

Depuis notre application Est-ce que nécessite ARCore, ouvrez le manifeste et ajoutez ce qui suit:

Il est également possible que votre application soit téléchargée sur un périphérique prenant en charge ARCore en théorie, mais sur lequel ARCore n’est pas installé. Une fois que nous avons marqué notre application comme «AR Required», Google Play téléchargera et installera automatiquement ARCore à côté de votre application, si celle-ci n’est pas déjà présente sur le périphérique cible.

Sachez simplement que même si votre application est Android: required = "true", vous aurez encore besoin de vérifier que ARCore est présent au moment de l’exécution, car il est possible que l’utilisateur ait peut-être désinstallé ARCore depuis le téléchargement de votre application, ou que sa version d’ARCore soit obsolète.

La bonne nouvelle est que nous utilisons ArFragment, qui vérifie automatiquement qu'ARCore est installé et à jour avant de créer. chaque Séance AR - encore une fois, c’est quelque chose que nous n’avons pas à mettre en œuvre manuellement.

2. AR facultatif

Si votre application inclut des fonctionnalités d'AR agréables à utiliser, mais non essentielles pour fournir ses fonctionnalités principales, vous pouvez marquer cette application comme «AR facultatif». Votre application peut alors vérifier si Google ARCore est présent à l'exécution et désactiver son affichage. Fonctionnalités AR sur les périphériques ne prenant pas en charge ARCore.

Si vous créez une application «AR Optional», ARCore ne pas être installé automatiquement avec votre application, même si le périphérique dispose de tout le matériel et de tous les logiciels nécessaires pour prendre en charge ARCore. Votre application «AR Optional» devra ensuite vérifier si ARCore est présent et à jour, puis télécharger la dernière version au fur et à mesure des besoins.

Si ARCore n’est pas crucial pour votre application, vous pouvez ajouter ce qui suit à votre manifeste:

Pendant que le manifeste est ouvert, j'ajoute également Android: configChanges et Android: screenOrientation, afin de m'assurer que MainActivity gère correctement les changements d'orientation.

Après avoir ajouté tout cela à votre manifeste, le fichier complet devrait ressembler à ceci:

Ajouter ArFragment à votre mise en page

J'utiliserai ArFragment d'ARCore, car il gère automatiquement un certain nombre de tâches clés d'ARCore au début de chaque session AR. En particulier, ArFragment vérifie qu'une version compatible d'ARCore est installée sur le périphérique et que l'application dispose actuellement de l'autorisation de l'appareil photo.

Une fois qu'ArFragment a vérifié que le périphérique peut prendre en charge les fonctions AR de votre application, il crée une session ArSceneView ARCore et l'expérience AR de votre application est prête à fonctionner!

Vous pouvez ajouter le fragment ArFragment à un fichier de présentation, exactement comme un fragment Android, ouvrez votre fichier activity_main.xml et ajoutez un composant «com.google.ar.sceneform.ux.ArFragment».

Téléchargement de modèles 3D à l’aide du logiciel Poly

Vous pouvez créer des éléments de rendu de différentes manières, mais dans cet article, nous utiliserons un fichier d’éléments 3D.

Sceneform prend en charge les ressources 3D aux formats .OBJ, .glTF et .FBX, avec ou sans animations. Il existe de nombreux endroits où vous pouvez acquérir des modèles 3D dans l’un de ces formats pris en charge, mais dans ce tutoriel, j’utiliserai un fichier .OBJ, téléchargé à partir du référentiel Poly de Google.

Rendez-vous sur le site Web de Poly et téléchargez l’actif que vous souhaitez utiliser au format .OBJ (j’utilise ce modèle T-Rex).

Décompressez le dossier, qui devrait contenir le fichier d'actif source de votre modèle (.OBJ, .FBX ou .glTF). Selon le modèle, ce dossier peut également contenir des dépendances de modèle, telles que des fichiers aux formats .mtl, .bin, .png ou .jpeg.

Importation de modèles 3D dans Android Studio

Une fois que vous avez votre actif, vous devez l'importer dans Android Studio à l'aide du plug-in Sceneform. Il s'agit d'un processus en plusieurs étapes qui vous oblige à:

Créez un dossier «sampledata». Sampledata est un nouveau type de dossier pour les exemples de données de conception qui ne sera pas inclus dans votre fichier APK, mais sera disponible dans l'éditeur Android Studio.
Glissez et déposez le fichier d'actif .OBJ d'origine dans votre dossier «sampledata».
Effectuez l'importation et la conversion de Sceneform sur le fichier .OBJ, qui générera les fichiers .sfa et .sfb.

Bien que cela puisse sembler plus simple, ne pas Faites glisser le fichier .OBJ directement dans le répertoire "res" de votre projet, car le modèle sera inutilement inclus dans votre fichier APK.

Les projets Android Studio ne contiennent pas de dossier «sampledata» par défaut. Vous devez donc en créer un manuellement:

Cliquez sur le dossier "app" de votre projet en maintenant la touche Contrôle enfoncée.
Sélectionnez «Nouveau> Répertoire de données exemple» et créez un dossier nommé «sampledata».
Accédez aux fichiers de modèle 3D que vous avez téléchargés précédemment. Recherchez le fichier d'actif source (.OBJ, .FBX ou .glTF), puis faites-le glisser et déposez-le dans le répertoire «sampledata».
Vérifiez si votre modèle a des dépendances (telles que des fichiers aux formats .mtl, .bin, .png ou .jpeg). Si vous trouvez l'un de ces fichiers, faites-les glisser et déposez-les dans le dossier «sampledata».
Dans Android Studio, cliquez sur le fichier source de votre modèle 3D (.OBJ, .FBX ou .glTF) en maintenant la touche Contrôle enfoncée, puis sélectionnez "Importer un actif Sceneform".

La fenêtre suivante affiche des informations sur les fichiers que Sceneform va générer, y compris l'emplacement de stockage du fichier .sfa résultant dans votre projet. Je vais utiliser le répertoire "raw".
Lorsque vous êtes satisfait des informations que vous avez entrées, cliquez sur "Terminer".

Cette importation apporte quelques modifications à votre projet. Si vous ouvrez votre fichier build.gradle, vous constaterez que le plug-in Sceneform a été ajouté en tant que dépendance de projet:

dependencies {classpath com.android.tools.build:gradle:3.5.0-alpha06 classpath com.google.ar.sceneform: plugin: 1.7.0 // NOTE: ne placez pas les dépendances de votre application ici; ils appartiennent // dans les fichiers individuels du module build.gradle}}

Ouvrez votre fichier build.gradle au niveau du module et vous trouverez une nouvelle entrée sceneform.asset () pour votre modèle 3D importé:

apply plugin: com.google.ar.sceneform.plugin // Le «chemin d'accès aux ressources source» que vous avez spécifié lors de l'importation // sceneform.asset (sampledata / dinosaur.obj, // le «chemin d'accès aux matières» que vous avez spécifié lors de l'importation // Par défaut , // Le “chemin de sortie .sfa” que vous avez spécifié lors de l'importation // sampledata / dinosaur.sfa, // Le “chemin de sortie .sfb” que vous avez spécifié lors de l'importation // src / main / assets / dinosaur)

Si vous examinez vos dossiers «sampledata» et «raw», vous verrez alors qu’ils contiennent respectivement de nouveaux fichiers .sfa et .sfb.

Vous pouvez prévisualiser le fichier .sfa dans le nouveau Sceneform Viewer d’Android Studio:

Sélectionnez «Affichage> Outils Windows> Viewer» dans la barre de menus d'Android Studio.
Dans le menu de gauche, sélectionnez votre fichier .sfa. Votre modèle 3D devrait maintenant apparaître dans la fenêtre du visualiseur.

Affichez votre modèle 3D

Notre tâche suivante consiste à créer une session AR qui comprend son environnement et permet à l'utilisateur de placer des modèles 3D dans une scène augmentée.

Cela nous oblige à faire ce qui suit:

1. Créer une variable membre ArFragment

ArFragment exécute la majeure partie des tâches lourdes liées à la création d'une session AR. Nous référencerons donc ce fragment dans notre classe MainActivity.

Dans l'extrait suivant, je crée une variable membre pour ArFragment puis l'initialise dans la méthode onCreate ():

arFragment privé arCoreFragment; @Override protected void onCreate (Bundle savedInstanceState) {super.onCreate (savedInstanceState); ... ... ...} setContentView (R.layout.activity_main); arCoreFragment = (ArFragment) // Trouver le fragment à l'aide du gestionnaire de fragments // getSupportFragmentManager (). findFragmentById (R.id.main_fragment);

2. Construire un ModelRenderable

Nous devons maintenant transformer notre fichier .sfb en un ModelRenderable, qui rendra éventuellement notre objet 3D.

Ici, je crée un ModelRenderable à partir du fichier .sfb res / raw / dinosaur de mon projet:

private ModelRenderable dinoRenderable; ... ... ... ModelRenderable.builder () .setSource (this, R.raw.dinosaur) .build () .thenAccept (renderable -> dinoRenderable = renderable) .exceptionnellement (throwable -> {Log.e ( TAG, "Impossible de charger le rendu"); return null;}); }

3. Répondre aux commentaires de l'utilisateur

ArFragment possède un support intégré pour les gestes de type tap, drag, pinch et twist.

Dans notre application, l'utilisateur va ajouter un modèle 3D à un plan ARCore, en tapotant ce plan.

Pour fournir cette fonctionnalité, nous devons enregistrer un rappel qui sera appelé chaque fois qu'un avion est exploité:

arCoreFragment.setOnTapArPlaneListener ((HitResult hitResult, Plan de l'avion, MotionEvent motionEvent) -> {if (dinoRenderable == null) {return;}

4. Ancrez votre modèle

Dans cette étape, nous allons récupérer un fichier ArSceneView et l’attacher à un AnchorNode, qui servira de nœud parent de la scène.

ArSceneView est responsable de l’exécution de plusieurs tâches importantes d’ARCore, notamment le rendu des images de caméra du périphérique et l’affichage d’une animation Sceneform UX montrant comment l’utilisateur doit tenir et déplacer son périphérique afin de démarrer l’expérience AR. ArSceneView mettra également en surbrillance tous les plans détectés, prêt à permettre à l'utilisateur de placer ses modèles 3D dans la scène.

Le composant ARSceneView est associé à une scène, qui est une structure de données parent-enfant contenant tous les nœuds à restituer.

Nous allons commencer par créer un nœud de type AnchorNode, qui agira en tant que nœud parent de notre ArSceneView.

Tous les nœuds d’ancrage restent dans la même position réelle. Ainsi, en créant un nœud d’ancre, nous nous assurons que nos modèles 3D resteront en place dans la scène augmentée.

Créons notre nœud d’ancrage:

AnchorNode anchorNode = new AnchorNode (ancre);

Nous pouvons ensuite récupérer un fichier ArSceneView à l'aide de getArSceneView () et l'attacher à l'AnchorNode:

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

5. Ajouter un support pour le déplacement, la mise à l'échelle et la rotation

Ensuite, je vais créer un nœud de type TransformableNode. Le TransformableNode est responsable du déplacement, de la mise à l'échelle et de la rotation des nœuds, en fonction des gestes de l'utilisateur.

Une fois que vous avez créé un TransformableNode, vous pouvez lui associer le rendu, ce qui donnera au modèle la possibilité d’agrandir et de se déplacer, en fonction de l’interaction de l’utilisateur. Enfin, vous devez connecter le TransformableNode au AnchorNode, dans une relation parent-enfant qui assure que le TransformableNode et Les rendus doivent rester en place dans la scène augmentée.

TransformableNode transformableNode = new TransformableNode (arCoreFragment.getTransformationSystem ()); // Connecte transformableNode à anchorNode // transformableNode.setParent (anchorNode); transformableNode.setRenderable (dinoRenderable); // Sélectionnez le nœud // transformableNode.select (); }); }

La MainActivity terminée

Après avoir effectué tout ce qui précède, votre MainActivity devrait ressembler à ceci:

importer android.app.Activity; importer android.app.ActivityManager; importer androidx.appcompat.app.AppCompatActivity; importer android.content.Context; importer android.net.Uri; importer android.os.Build; importer android.os.Build.VERSION_CODES; importer android.os.Bundle; importer android.util.Log; importer android.view.MotionEvent; import androidx.annotation.RequiresApi; importer com.google.ar.core.Anchor; importer com.google.ar.core.HitResult; importer 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 publique MainActivity étend AppCompatActivity {private static final String TAG = MainActivity.class.getSimpleName (); privé statique final double MIN_OPENGL_VERSION = 3.0; // Créer une variable membre pour ModelRenderable // private ModelRenderable dinoRenderable; // Créer une variable membre pour ArFragment // private ArFragment arCoreFragment; @RequiresApi (api = VERSION_CODES.N) @Override protected void onCreate (Bundle savedInstanceState) {super.onCreate (savedInstanceState); if (! checkDevice ((this)))) {return; } setContentView (R.layout.activity_main); arCoreFragment = (ArFragment) // Trouver le fragment à l'aide du gestionnaire de fragments // getSupportFragmentManager (). findFragmentById (R.id.main_fragment); if (Build.VERSION.SDK_INT> = VERSION_CODES.N) {// Construit le ModelRenderable // ModelRenderable.builder () .setSource (this, R.raw.dinosaur) .build () .thenAccept (rendu -> dinoRenderable => rendu ) exceptionnellement (// Si une erreur se produit ... // throwable -> {//...envoie ensuite le texte suivant à Logcat // Log.e (TAG, "Impossible de charger le rendu"); return null;} ) } // Ecoute des événements onTap // arCoreFragment.setOnTapArPlaneListener ((HitResult hitResult, Plan de l’avion, MotionEvent motionEvent) -> {if (dinoRenderable == null) {return;} Ancre ancre = hitResult.createAnchor (); noeud de type AnchorNode // AnchorNode anchorNode = new AnchorNode (anchor); // connecte l'AnchorNode à la scène // anchorNode.setParent (arCoreFragment.getArSceneView (). getScene ()); // construit un noeud de type TransformableNode //. TransformableNode transformableNode = new TransformableNode (arCoreFragment.getTransformationSystem ()); // Connectez le TransformableNode à AnchorNode // transformableNode.setParent (anchorNode); // Liez le Renderable // transformableNode.setRenderable (dinoRenderable); // Définissez le noeud rendu / transformableNode.select ();}); } public statique boDien checkDevice (Activité finale) {// Si l'appareil exécute Android Marshmallow ou une version antérieure ... // if (Build.VERSION.SDK_INT <VERSION_CODES.N) {//...affiche ensuite les informations suivantes à Logcat // Log.e (TAG, "Sceneform requiert Android N ou une version ultérieure"); activité.finir (); retourne faux; } String openGlVersionString = ((ActivityManager) activity.getSystemService (Context.ACTIVITY_SERVICE)) .getDeviceConfigurationInfo () // Vérification de la version de OpenGL ES // .getGlEsVersion (); // Si le périphérique exécute une version inférieure à OpenGL ES 3.0 ... // if (Double.parseDouble (openGlVersionString) <MIN_OPENGL_VERSION) {//...affiche ensuite le texte suivant dans Logcat // Log.e (TAG, " Nécessite OpenGL ES 3.0 ou supérieur "); activité.finir (); retourne faux; } return true; }}

Vous pouvez télécharger le projet terminé à partir de GitHub.

Test de votre application de réalité augmentée Google ARCore

Vous êtes maintenant prêt à tester votre application sur un périphérique Android physique pris en charge. Si vous ne possédez pas d'appareil prenant en charge ARCore, vous pouvez tester votre application AR dans l'émulateur Android (avec un peu de configuration supplémentaire, que nous verrons dans la section suivante).

Pour tester votre projet sur un physique Appareil Android:

Installez votre application sur le périphérique cible.
Lorsque vous y êtes invité, accordez à l'application l'accès à la caméra de votre appareil.
Si vous êtes invité à installer ou à mettre à jour l'application ARCore, appuyez sur «Continuer», puis complétez la boîte de dialogue pour vous assurer que vous utilisez la version la plus récente et la plus performante d'ARCore.
Vous devriez maintenant voir une vue de la caméra, complétée par l’animation d’une main tenant un appareil. Pointez la caméra sur une surface plane et déplacez votre appareil dans un mouvement circulaire, comme le montre l'animation. Après quelques instants, une série de points devrait apparaître, indiquant qu'un avion a été détecté.

Une fois que vous êtes satisfait de la position de ces points, donnez-leur une tape - votre modèle 3D devrait maintenant apparaître sur le plan choisi!

Essayez de vous déplacer physiquement autour du modèle. En fonction de votre environnement, vous pourrez peut-être faire le tour complet à 360 degrés. Vous devez également vérifier que l’objet projette une ombre conforme aux sources de lumière du monde réel.

Test d'ARCore sur un périphérique virtuel Android

Pour tester vos applications ARCore dans un appareil virtuel Android, vous aurez besoin de la version 27.2.9 ou supérieure d’Android Emulator. Vous devez également être connecté à Google Play Store sur votre AVD et activer OpenGL ES 3.0 ou version ultérieure.

Pour vérifier si OpenGL ES 3.0 ou version ultérieure est actuellement activé sur votre AVD:

Lancez votre AVD, comme d'habitude.
Ouvrez une nouvelle fenêtre de terminal (Mac) ou une invite de commande (Windows).
Modifiez le répertoire («cd») de sorte que l’invite de terminal / de commande pointe vers l’emplacement du programme «adb» de votre SDK Android. Par exemple, ma commande ressemble à ceci:

Cd / Utilisateurs / jessicathornsby / Bibliothèque / Android / sdk / platform-tools

Appuyez sur la touche "Entrée" de votre clavier.
Copiez / collez la commande suivante dans le terminal, puis appuyez sur la touche «Entrée»:

./adb logcat | grep eglMakeCurrent

Si le terminal renvoie «ver 3 0» ou plus, OpenGL ES est correctement configuré. Si le terminal ou l’invite de commande affiche une version antérieure à la version 3.0, vous devez activer OpenGL ES 3.0:

Revenez à votre AVD.
Recherchez la bande de boutons «Contrôle étendu» qui flotte à côté de l'émulateur Android, puis sélectionnez «Paramètres> Avancé».
Naviguez jusqu'à «Niveau de l'API OpenGL ES> Renderer maximum (jusqu'à OpenGL ES 3.1)».
Redémarrez l'émulateur.

Dans la fenêtre Terminal / Invite de commandes, copiez / collez la commande suivante, puis appuyez sur la touche «Entrée».

./adb logcat | grep eglMakeCurrent

Vous devriez maintenant obtenir un résultat de «ver 3 0» ou plus, ce qui signifie qu'OpenGL ES est configuré correctement.

Enfin, assurez-vous que votre AVD exécute la toute dernière version d’ARCore:

Rendez-vous sur la page GitHub d’ARCore et téléchargez la dernière version d’ARCore pour l’émulateur. Par exemple, au moment de la rédaction de cette publication, la version la plus récente était «ARCore_1.7.0.x86_for_emulator.apk».
Glissez-déposez l'APK sur votre AVD en cours d'exécution.

Pour tester votre projet sur un DAV, installez votre application et accordez-lui l’accès à la «caméra» de l’AVD lorsque vous y êtes invité.

Vous devriez maintenant voir une vue de la caméra d'une pièce simulée. Pour tester votre application, déplacez-vous dans cet espace virtuel, recherchez une surface plane simulée et cliquez pour placer un modèle sur cette surface.

Vous pouvez déplacer la caméra virtuelle dans la pièce virtuelle en maintenant enfoncées les touches «Option» (macOS) ou «Alt» (Linux ou Windows), puis en utilisant l'un des raccourcis clavier suivants:

Déplacer à gauche ou à droite. Appuyez sur A ou D.
Descendre ou monter. Appuyez sur Q ou E.
Avancer ou reculer. Appuyez sur W ou S.

Vous pouvez également «vous déplacer» autour de la scène virtuelle en appuyant sur «Option» ou «Alt», puis en utilisant votre souris. Cela peut sembler un peu maladroit au début, mais avec la pratique, vous devriez être capable d'explorer avec succès l'espace virtuel. Une fois que vous avez trouvé un plan simulé, cliquez sur les points blancs pour placer votre modèle 3D sur cette surface.

Emballer

Dans cet article, nous avons créé une application de réalité augmentée simple, utilisant ARCore et le plugin Sceneform.

Si vous décidez d'utiliser Google ARCore dans vos propres projets, assurez-vous de partager vos créations dans les commentaires ci-dessous!