Bygg en augmented reality-app med Google ARCore

Video: Flyg PS752 Augmented Reality Memorial Animation Explainer Iran Plane Crash Victims BOOOOOM

Innhold

Importerer 3D-modeller med Sceneform-pluginen
Installere Sceneform-pluginen
Sceneform UX og Java 8: Oppdatere prosjektavhengighetene dine
Be om tillatelser med ArFragment
AR påkrevd eller valgfri?
1. AR påkrevd
2. AR Valgfritt
Legg ArFragment til oppsettet
Last ned 3D-modeller ved å bruke Googles Poly
Importerer 3D-modeller til Android Studio
Vis din 3D-modell
1. Opprett en ArFragment-medlemsvariabel
2. Bygg en ModelRenderable
3. Svar på brukerinndata
4. Forankre modellen din
5. Legg til støtte for bevegelse, skalering og rotering
Den fullførte MainActivity
Testing av Google ARCore-utvidet reality-appen din
Testing av ARCore på en virtuell Android-enhet
Innpakking

Importerer 3D-modeller med Sceneform-pluginen

Vanligvis krever arbeid med 3D-modeller spesialistkunnskap, men med utgivelsen av Sceneform-pluginen har Google gjort det mulig å gjengi 3D-modeller ved hjelp av Java - og uten å måtte lære OpenGL.

Sceneform-plugin-en gir et API på høyt nivå som du kan bruke til å lage Renderdables fra standard Android-widgeter, former eller materialer, eller fra 3D-eiendeler, for eksempel .OBJ- eller .FBX-filer.

I prosjektet vårt bruker vi Sceneform-pluginen for å importere en .OBJ-fil til Android Studio. Hver gang du importerer en fil ved hjelp av Sceneform, vil denne pluginen automatisk:

Konverter ressursfilen til en .sfb-fil. Dette er et runtime-optimalisert Sceneform Binary-format (.sfb) som er lagt til APK-en din og deretter lastet inn under kjøretid. Vi bruker denne .sfb-filen for å lage en Renderable, som består av masker, materialer og teksturer, og kan plasseres hvor som helst i den forsterkede scenen.
Generer en .sfa-fil. Dette er en eiendomsbeskrivelsesfil, som er en tekstfil som inneholder en menneskelig lesbar beskrivelse av .sfb-filen. Avhengig av modell, kan det hende du kan endre utseendet ved å redigere teksten i .sfa-filen.

Bare vær oppmerksom på at Sceneform-pluginen i skrivende stund fremdeles var i beta, slik at du kan støte på feil, feil eller annen merkelig oppførsel når du bruker denne plugin-modulen.

Installere Sceneform-pluginen

Sceneform-pluginen krever Android Studio 3.1 eller nyere. Hvis du er usikker på hvilken versjon av Android Studio du bruker, velger du "Android Studio> Om Android Studio" på verktøylinjen. Den påfølgende popup inneholder grunnleggende informasjon om Android Studio-installasjonen, inkludert versjonsnummer.

Slik installerer du Sceneform-plugin:

Hvis du er på en Mac, velger du "Android Studio> Innstillinger ..." fra verktøylinjen til Android Studio, og deretter velger du "Plugins" fra venstre meny. Hvis du er på en Windows-PC, velger du "File> Settings> Plugins> Browse repositories."
Søk etter "Sceneform." Når "Google Sceneform Tools" vises, velger du "Install".
Start Android Studio på nytt når du blir bedt om det, og pluginen din er klar til bruk.

Sceneform UX og Java 8: Oppdatere prosjektavhengighetene dine

La oss begynne med å legge til avhengighetene vi bruker i løpet av dette prosjektet. Åpne build.gradle-filen på modulnivå, og legg til Sceneform UX-biblioteket, som inneholder ArFragmentet vi bruker i oppsettet:

avhengigheter {implementeringsfilTree (dir: libs, inkluderer:) implementering androidx.appcompat: appcompat: 1.0.2 implementering androidx.constraintlayout: constraintlayout: 1.1.3 testImplementering junit: junit: 4.12 androidTestImplementation androidx.test.ext: junit: 1.1.0 androidTestImplementation androidx.test.espresso: espresso-core: 3.1.1 // Sceneform UX gir UX-ressurser, inkludert ArFragment // implementering "com.google.ar.sceneform.ux: sceneform-ux: 1.7.0" implementering "com. android.support:appcompat-v7:28.0.0 "}

Sceneform bruker språkkonstruksjoner fra Java 8, så vi må også oppdatere prosjektets kildekompatibilitet og målkompatibilitet til Java 8:

compileOptions {sourceCompatibility JavaVersion.VERSION_1_8 targetCompatibility JavaVersion.VERSION_1_8}

Endelig må vi bruke Sceneform-plugin:

bruk plugin: com.google.ar.sceneform.plugin

Den ferdige build.gradle-filen skal se slik ut:

bruke plugin: com.android.application android {compileSdkVersion 28 defaultConfig {applicationId "com.jessicathornsby.arcoredemo" minSdkVersion 23 targetSdkVersion 28 versionCode 1-versjonName "1.0" testInstrumentationRunner "androidx.test.runner.RunnerViews JavaVersion.VERSION_1_8} buildTypes {release {minifyEnabled false proguardFiles getDefaultProguardFile (proguard-android-optimize.txt), proguard-rules.pro}}} avhengigheter {implementeringsfilTree (dir: libs, inkluderer:) implementering androidx.appcompat: appcompat: 1.0 .2 implementering androidx.constraintlayout: constraintlayout: 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 implementering "com.google. ar.sceneform.ux: sceneform-ux: 1.7.0 "implementering" com.android.support:appcompat-v7:28.0.0 "} bruke plugin: com.google.ar .sceneform.plugin

Be om tillatelser med ArFragment

Vår applikasjon vil bruke enhetens kamera for å analysere omgivelsene og posisjonere 3D-modeller i den virkelige verden. Før applikasjonen vår får tilgang til kameraet, krever det kameraets tillatelse, så åpne prosjektets manifest og legg til følgende:

Android 6.0 ga brukerne muligheten til å gi, nekte og tilbakekalle tillatelser på tillatelse etter tillatelse. Selv om dette forbedret brukeropplevelsen, må Android-utviklere nå manuelt be om tillatelser under kjøretid og håndtere brukerens svar. Den gode nyheten er at når du jobber med Google ARCore, implementeres prosessen med å be om kameraet tillatelse og håndtere brukerens svar automatisk.

ArFragment-komponenten sjekker automatisk om appen din har kameraet tillatelse, og ber om den om nødvendig før du oppretter AR-økten. Siden vi bruker ArFragment i appen vår, trenger vi ikke å skrive noen kode for å be om kameraets tillatelse.

AR påkrevd eller valgfri?

Det er to typer applikasjoner som bruker AR-funksjonalitet:

1. AR påkrevd

Hvis applikasjonen din er avhengig av Google ARCore for å levere en god brukeropplevelse, må du sørge for at den bare noen gang er lastet ned til enheter som støtter ARCore. Hvis du merker appen din som "AR påkrevd", vil den bare vises i Google Play-butikken, hvis enheten støtter ARCore.

Siden søknaden vår gjør krever ARCore, åpne manifestet og legg til følgende:

Det er også en sjanse for at applikasjonen din kan lastes ned til en enhet som støtter ARCore i teorien, men ARCore ikke har installert faktisk. Når vi har merket appen vår som "AR påkrevd", vil Google Play automatisk laste ned og installere ARCore ved siden av appen din, hvis den ikke allerede er til stede på målenheten.

Bare vær oppmerksom på at selv om appen din er Android: required = "true", vil du gjøre det fortsatt trenger å sjekke at ARCore er til stede på kjøretid, fordi det er en sjanse for at brukeren kan ha avinstallert ARCore siden de lastet ned appen din, eller at versjonen av ARCore er utdatert.

Den gode nyheten er at vi bruker ArFragment, som automatisk sjekker at ARCore er installert og oppdatert før du oppretter Hver AR-økt - så nok en gang, dette er noe vi ikke trenger å implementere manuelt.

2. AR Valgfritt

Hvis appen din inneholder AR-funksjoner som er fine å ha, men ikke avgjørende for å levere sin kjernefunksjonalitet, kan du merke denne applikasjonen som "AR Valgfritt." Appen din kan deretter sjekke om Google ARCore er til stede på runtime, og deaktivere dens AR-funksjoner på enheter som ikke støtter ARCore.

Hvis du oppretter en "AR Valgfri" -app, vil ARCore gjøre det ikke installeres automatisk ved siden av applikasjonen din, selv om enheten har all maskinvaren og programvaren som kreves for å støtte ARCore. Deretter vil AR-appen din sjekke om ARCore er til stede og oppdatert, og laste ned den nyeste versjonen etter behov.

Hvis ARCore ikke er avgjørende for appen din, kan du legge til følgende i manifestet:

Mens jeg har manifestet åpent, legger jeg også til Android: configChanges og android: screenOrientation, for å sikre at MainActivity håndterer orienteringsendringer grasiøst.

Etter å ha lagt til alt dette til manifestet ditt, skal den ferdige filen se slik ut:

Legg ArFragment til oppsettet

Jeg bruker ARCores ArFragment, ettersom den automatisk håndterer en rekke viktige ARCore-oppgaver ved starten av hver AR-økt. Spesielt bemerkes at ArFragment sjekker at en kompatibel versjon av ARCore er installert på enheten, og at appen for øyeblikket har kameraet tillatelse.

Når ArFragment har bekreftet at enheten kan støtte appens AR-funksjoner, oppretter den en ArSceneView ARCore-økt, og appens AR-opplevelse er klar til å gå!

Du kan legge ArFragment-fragmentet til en layoutfil, akkurat som et vanlig Android Fragment, så åpne Activity_main.xml-filen og legg til en "com.google.ar.sceneform.ux.ArFragment" -komponent.

Last ned 3D-modeller ved å bruke Googles Poly

Det er flere forskjellige måter du kan lage Renderables på, men i denne artikkelen bruker vi en 3D-aktivafil.

Sceneform støtter 3D-eiendeler i .OBJ, .glTF og .FBX formater, med eller uten animasjoner. Det er mange steder hvor du kan skaffe 3D-modeller i et av disse støttede formatene, men i denne opplæringen bruker jeg en .OBJ-fil, lastet ned fra Googles Poly-depot.

Gå over til Poly-nettstedet og last ned eiendelen du vil bruke, i .OBJ-format (jeg bruker denne T-Rex-modellen).

Pakk ut mappen, som skal inneholde modellens kildetilleggsfil (.OBJ, .FBX eller .glTF). Avhengig av modell, kan denne mappen også inneholde noen modellavhengigheter, for eksempel filer i formatene .mtl, .bin, .png eller .jpeg.

Importerer 3D-modeller til Android Studio

Når du har eiendelen din, må du importere den til Android Studio ved å bruke Sceneform-pluginen. Dette er en flertrinnsprosess som krever at du:

Lag en "sampledata" -mappe. Sampledata er en ny mappetype for designdataeksempeldata som ikke blir inkludert i APK-en din, men som vil være tilgjengelig i Android Studio-redigereren.
Dra og slipp den originale .OBJ-aktiva-filen til "sampledata" -mappen.
Utfør Sceneform import og konvertering på .OBJ-filen, som vil generere .sfa- og .sfb-filene.

Selv om det kan virke mer greit, ikke dra og slipp .OBJ-filen direkte i prosjektets “res” -katalog, da dette vil føre til at modellen blir inkludert i APK unødvendig.

Android Studio-prosjekter inneholder ikke en "sampledata" -mappe som standard, så du må opprette en manuelt:

Kontroll-klikk på prosjektets "app" -mappe.
Velg "Ny> Eksempeldatakatalog" og opprett en mappe som heter "sampledata."
Naviger til 3D-modellfilene du lastet ned tidligere. Finn kildeprofilfilen (.OBJ, .FBX eller .glTF) og dra og slipp den inn i "sampledata" -katalogen.
Sjekk om modellen din har noen avhengigheter (for eksempel filer i formatene .mtl, .bin, .png eller .jpeg). Hvis du finner noen av disse filene, kan du dra og slippe dem i "sampledata" -mappen.
I Android Studio kontrollerer du 3D-modellkildefilen din (.OBJ, .FBX eller .glTF), og velg deretter "Import Sceneform Asset."

Det påfølgende vinduet viser noe informasjon om filene som Sceneform kommer til å generere, inkludert hvor den resulterende .sfa-filen blir lagret i prosjektet ditt; Jeg kommer til å bruke den "rå" katalogen.
Når du er fornøyd med informasjonen du har lagt inn, klikker du på Fullfør.

Denne importen gjør noen få endringer i prosjektet ditt. Hvis du åpner build.gradle-filen, vil du se at Sceneform-pluginen er lagt til som en prosjektavhengighet:

avhengigheter {classpath com.android.tools.build:gradle:3.5.0-alpha06 classpath com.google.ar.sceneform: plugin: 1.7.0 // MERK: Ikke plasser søknadsavhengighetene dine her; de hører hjemme // i den enkelte modul build.gradle-filer}}

Åpne modulenivå build.gradle-filen din, så finner du en ny sceneform.asset () -oppføring for din importerte 3D-modell:

bruke plugin: com.google.ar.sceneform.plugin // "Source Asset Path" du spesifiserte under import // sceneform.asset (sampledata / dinosaur.obj, // "Material Path" du spesifiserte under import // Standard , // ".sfa Output Path" du spesifiserte under import // sampledata / dinosaur.sfa, // ".sfb Output Path" du spesifiserte under import // src / main / asset / dinosaur)

Hvis du tar en titt på mappene "sampledata" og "rå", vil du se at de inneholder henholdsvis nye .sfa- og .sfb-filer.

Du kan forhåndsvise .sfa-filen i Android Studios nye Sceneform Viewer:

Velg "Vis> Verktøy Windows> Viewer" fra Android Studio menylinjen.
I menyen til venstre velger du .sfa-filen. 3D-modellen din skal nå vises i visningsvinduet.

Vis din 3D-modell

Vår neste oppgave er å lage en AR-økt som forstår omgivelsene, og lar brukeren plassere 3D-modeller i en forsterket scene.

Dette krever at vi gjør følgende:

1. Opprett en ArFragment-medlemsvariabel

ArFragment utfører mye av det tunge løftet som er involvert i å lage en AR-økt, så vi refererer til dette fragmentet i hele vår MainActivity-klasse.

I følgende tekstutdrag oppretter jeg en medlemsvariabel for ArFragment og initialiserer den deretter på onCreate () -metoden:

privat arFragment arCoreFragment; @Override beskyttet tomrom onCreate (Bundle savedInstanceState) {super.onCreate (savedInstanceState); ... ... ...} setContentView (R.layout.activity_main); arCoreFragment = (ArFragment) // Finn fragmentet ved hjelp av fragment manager // getSupportFragmentManager (). findFragmentById (R.id.main_fragment);

2. Bygg en ModelRenderable

Vi må nå transformere .sfb-filen vår til en ModelRenderable, som til slutt vil gjøre 3D-objektet vårt.

Her lager jeg en ModelRenderable fra prosjektets res / raw / dinosaur .sfb-fil:

private ModelRenderable dinoRenderable; ... ... ... ModelRenderable.builder () .setSource (dette, R.raw.dinosaur) .build () .thenAccept (renderable -> dinoRenderable = renderable) .exceptually (throwable -> {Log.e ( TAG, "Kan ikke laste gjengitt"); return null;}); }

3. Svar på brukerinndata

ArFragment har innebygd støtte for trykk, dra, klype og vri bevegelser.

I appen vår vil brukeren legge til en 3D-modell til et ARCore-fly, ved å gi det flyet et trykk.

For å levere denne funksjonaliteten, må vi registrere en tilbakeringing som blir påkalt hver gang et fly tappes:

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

4. Forankre modellen din

I dette trinnet skal vi hente en ArSceneView og knytte den til en AnchorNode, som vil fungere som scenens overordnede node.

ArSceneView er ansvarlig for å utføre flere viktige ARCore-oppgaver, inkludert gjengivelse av enhetens kamerabilder, og visning av en Sceneform UX-animasjon som viser hvordan brukeren skal holde og flytte enheten sin for å starte AR-opplevelsen. ArSceneView vil også fremheve alle planene den oppdager, klar til at brukeren kan plassere 3D-modellene sine i scenen.

ARSceneView-komponenten har en scene festet til den, som er en foreldre-barn datastruktur som inneholder alle nodene som må gjengis.

Vi kommer til å starte med å opprette en node av typen AnchorNode, som vil fungere som vår ArSceneViews overordnede node.

Alle forankringsnoder forblir i den samme posisjonen i den virkelige verden, så ved å opprette en ankernode sikrer vi at 3D-modellene våre forblir faste på plass i den forsterkede scenen.

La oss lage vår ankernode:

AnchorNode anchorNode = nytt AnchorNode (anker);

Vi kan deretter hente en ArSceneView ved å bruke getArSceneView (), og feste den til AnchorNode:

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

5. Legg til støtte for bevegelse, skalering og rotering

Deretter skal jeg opprette en node av typen TransformableNode. TransformableNode er ansvarlig for å flytte, skalere og rotere noder, basert på brukerbevegelser.

Når du har opprettet en TransformableNode, kan du legge ved den Renderable, som vil gi modellen muligheten til å skalere og bevege seg, basert på brukerinteraksjon. Til slutt må du koble TransformableNode til AnchorNode, i et barn-foreldre forhold som sikrer TransformableNode og Renderable forblir fast på plass i den forsterkede scenen.

TransformableNode transformableNode = new TransformableNode (arCoreFragment.getTransformationSystem ()); // Koble transformableNode til anchorNode // transformableNode.setParent (anchorNode); transformableNode.setRenderable (dinoRenderable); // Velg noden // transformableNode.select (); }); }

Den fullførte MainActivity

Etter å ha utført alle de ovennevnte, bør MainActivity se slik ut:

import android.app.Aktivitet; 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; offentlig klasse MainActivity utvider AppCompatActivity {privat statisk final String TAG = MainActivity.class.getSimpleName (); privat statisk endelig dobbel MIN_OPENGL_VERSION = 3.0; // Opprett en medlemsvariabel for ModelRenderable // private ModelRenderable dinoRenderable; // Opprett en medlemsvariabel for ArFragment // private ArFragment arCoreFragment; @RequiresApi (api = VERSION_CODES.N) @Override beskyttet tomrom onCreate (Bundle savedInstanceState) {super.onCreate (savedInstanceState); if (! checkDevice ((dette))) {return; } setContentView (R.layout.activity_main); arCoreFragment = (ArFragment) // Finn fragmentet ved å bruke fragment manager // getSupportFragmentManager (). findFragmentById (R.id.main_fragment); if (Build.VERSION.SDK_INT> = VERSION_CODES.N) {// Build ModelRenderable // ModelRenderable.builder () .setSource (dette, R.raw.dinosaur) .build () .thenAccept (renderable -> dinoRenderable = renderable) ). eksepsjonelt (// Hvis det oppstår en feil ... // kastbar -> {//... deretter skriver du ut følgende til Logcat // Log.e (TAG, "Kan ikke laste gjengitt"); return null;} ); } // Lytt etter onTap-hendelser // arCoreFragment.setOnTapArPlaneListener ((HitResult hitResult, Plane plane, MotionEvent motionEvent) -> {if (dinoRenderable == null) {return;} Anchor anchor = hitResult.createAnchor (); // Build a node av typen AnchorNode // AnchorNode anchorNode = new AnchorNode (anker); // Koble AnchorNode til Scene // anchorNode.setParent (arCoreFragment.getArSceneView (). getScene ()); // Bygg en node av typen TransformableNode // TransformableNode transformableNode = new TransformableNode (arCoreFragment.getTransformationSystem ()); // Koble TransformableNode til AnchorNode // transformableNode.setParent (anchorNode); // Sett Renderable // transformableNode.setRenderable (dinoRenderable); // Sett noden / / transformableNode.select ();}); } offentlig statisk boolsk checkDevice (endelig aktivitetsaktivitet) {// Hvis enheten kjører Android Marshmallow eller tidligere ... // if (Build.VERSION.SDK_INT <VERSION_CODES.N) {//... deretter skriver du ut følgende til Logcat // Log.e (TAG, "Sceneform krever Android N eller høyere"); activity.finish (); return falsk; } String openGlVersionString = ((ActivityManager) aktivitet.getSystemService (Context.ACTIVITY_SERVICE)) .getDeviceConfigurationInfo () // Sjekk versjonen av OpenGL ES // .getGlEsVersion (); // Hvis enheten kjører noe mindre enn OpenGL ES 3.0 ... // if (Double.parseDouble (openGlVersionString) <MIN_OPENGL_VERSION) {//... deretter skriv ut følgende til Logcat // Log.e (TAG, " Krever OpenGL ES 3.0 eller høyere "); activity.finish (); return falsk; } return true; }}

Du kan laste ned det ferdige prosjektet fra GitHub.

Testing av Google ARCore-utvidet reality-appen din

Du er nå klar til å teste applikasjonen din på en fysisk, støttet Android-enhet. Hvis du ikke eier en enhet som støtter ARCore, er det mulig å teste AR-appen din i Android Emulator (med litt ekstra konfigurasjon, som vi vil dekke i neste avsnitt).

For å teste prosjektet ditt på en fysisk Android-enhet:

Installer applikasjonen din på målenheten.
Når du blir bedt om det, gi applikasjonen tilgang til enhetens kamera.
Hvis du blir bedt om å installere eller oppdatere ARCore-appen, trykker du på "Fortsett" og fullfører deretter dialogen for å sikre at du kjører den siste og beste versjonen av ARCore.
Nå skal du se en kameravisning, komplett med en animasjon av en hånd som holder en enhet. Pek kameraet på en flat overflate og beveg enheten din i en sirkulær bevegelse, som demonstrert av animasjonen. Etter noen få øyeblikk skulle en serie med prikker dukke opp, som indikerer at et fly er blitt oppdaget.

Når du er fornøyd med plasseringen av disse prikkene, kan du gi dem et trykk - 3D-modellen skal nå vises på det valgte planet!

Prøv å bevege deg fysisk rundt modellen; avhengig av omgivelsene dine, kan det hende du kan gjøre hele 360 grader rundt det. Du bør også sjekke at objektet kaster en skygge som er i samsvar med lyskildene fra den virkelige verden.

Testing av ARCore på en virtuell Android-enhet

For å teste ARCore-appene dine i en Android Virtual Device (AVD), trenger du Android Emulator versjon 27.2.9 eller nyere. Du må også være logget på Google Play-butikken på AVD-en, og ha OpenGL ES 3.0 eller nyere aktivert.

Slik kontrollerer du om OpenGL ES 3.0 eller nyere er aktivert på AVD-en din:

Start AVD, som normalt.
Åpne et nytt terminalvindu (Mac) eller en ledetekst (Windows).
Endre katalog (“cd”) slik at terminalen / kommandoprompten peker på stedet for Android SDKs “adb” -program, for eksempel ser kommandoen min slik:

Cd / Brukere / jessicathornsby / Bibliotek / Android / sdk / plattformverktøy

Trykk "Enter" -tasten på tastaturet.
Kopier / lim inn neste kommando i terminalen, og trykk deretter "Enter" -tasten:

./adb logcat | grep eglMakeCurrent

Hvis terminalen returnerer “ver 3 0” eller høyere, er OpenGL ES konfigurert riktig. Hvis terminalen eller ledeteksten viser noe tidligere enn 3.0, må du aktivere OpenGL ES 3.0:

Bytt tilbake til AVD-en.
Finn stripen med "Utvidet kontroll" -knapper som flyter langs Android Emulator, og velg deretter "Innstillinger> Avansert."
Naviger til “OpenGL ES API-nivå> Maksimal gjengivelse (opp til OpenGL ES 3.1).”
Start emulatoren på nytt.

I vinduet Terminal / Command Prompt, kopier / lim inn følgende kommando og trykk deretter "Enter" -tasten "

./adb logcat | grep eglMakeCurrent

Du bør nå få et resultat av “ver 3 0” eller høyere, noe som betyr at OpenGL ES er riktig konfigurert.

Til slutt, sørg for at AVD kjører den aller nyeste versjonen av ARCore:

Gå over til ARCores GitHub-side, og last ned den siste utgivelsen av ARCore for emulatoren. For eksempel var den siste utgaven i skrivende stund “ARCore_1.7.0.x86_for_emulator.apk”
Dra og slipp APK-en på det løpende AVD-kortet.

For å teste prosjektet ditt på en AVD, installer applikasjonen din og gi den tilgang til AVDs “kamera” når du blir bedt om det.

Du skal nå se et kameravisning av et simulert rom. For å teste applikasjonen din, beveg deg rundt i dette virtuelle rommet, finn en simulert flat overflate og klikk for å plassere en modell på denne overflaten.

Du kan flytte det virtuelle kameraet rundt det virtuelle rommet ved å trykke og holde inne “Alternativ” (macOS) eller “Alt” (Linux eller Windows) -tastene, og deretter bruke en av følgende hurtigtaster:

Flytt til venstre eller høyre. Trykk på A eller D.
Gå ned eller opp. Trykk på Q eller E.
Gå fremover eller bakover. Trykk på W eller S.

Du kan også "bevege deg" rundt den virtuelle scenen ved å trykke "Alternativ" eller "Alt" og deretter bruke musen. Dette kan føles litt klatt med det første, men med praksis bør du være i stand til å utforske det virtuelle rommet. Når du har funnet et simulert plan, klikker du de hvite prikkene for å plassere 3D-modellen din på denne overflaten.

Innpakking

I denne artikkelen opprettet vi en enkel augmented reality-app, ved hjelp av ARCore og Sceneform-plugin.

Hvis du bestemmer deg for å bruke Google ARCore i dine egne prosjekter, må du huske å dele kreasjonene dine i kommentarfeltet nedenfor!