Inhoud

• 3D-modellen importeren met de Sceneform-plug-in
• De Sceneform-plug-in installeren
• Sceneform UX en Java 8: uw projectafhankelijkheden bijwerken
• Toestemmingen aanvragen met ArFragment
• AR Vereist of optioneel?
• 1. AR vereist
• 2. AR Optioneel
• Voeg ArFragment toe aan uw lay-out
• 3D-modellen downloaden met behulp van de Poly van Google
• 3D-modellen importeren in Android Studio
• Geef uw 3D-model weer
• 1. Maak een ArFragment-lidvariabele
• 2. Bouw een ModelRenderable
• 3. Reageren op gebruikersinvoer
• 4. Veranker uw model
• 5. Ondersteuning toevoegen voor verplaatsen, schalen en roteren
• De voltooide MainActivity
• Uw Google ARCore augmented reality-app testen
• ARCore testen op een virtueel Android-apparaat
• Afsluiten

3D-modellen importeren met de Sceneform-plug-in

Gewoonlijk vereist het werken met 3D-modellen specialistische kennis, maar met de release van de Sceneform-plug-in heeft Google het mogelijk gemaakt om 3D-modellen weer te geven met behulp van Java - en zonder OpenGL moeten leren.

De Sceneform-plug-in biedt een API op hoog niveau die u kunt gebruiken om Renderdables te maken van standaard Android-widgets, vormen of materialen, of van 3D-middelen, zoals .OBJ- of .FBX-bestanden.

In ons project zullen we de Sceneform-plug-in gebruiken om een ​​.OBJ-bestand in Android Studio te importeren. Wanneer u een bestand importeert met Sceneform, zal deze plug-in automatisch:

• Converteer het activabestand naar een .sfb-bestand. Dit is een voor runtime geoptimaliseerde Sceneform Binary-indeling (.sfb) die aan uw APK is toegevoegd en vervolgens tijdens runtime is geladen. We zullen dit .sfb-bestand gebruiken om een ​​Renderable te maken, die bestaat uit mazen, materialen en structuren en overal in de vergrote scène kan worden geplaatst.
• Genereer een .sfa-bestand. Dit is een activabeschrijvingsbestand, een tekstbestand met een voor mensen leesbare beschrijving van het .sfb-bestand. Afhankelijk van het model kunt u mogelijk het uiterlijk wijzigen door de tekst in het .sfa-bestand te bewerken.

Houd er rekening mee dat de Sceneform-plug-in op het moment van schrijven nog in bèta was, dus je kunt fouten, fouten of ander vreemd gedrag tegenkomen tijdens het gebruik van deze plug-in.

De Sceneform-plug-in installeren

De Sceneform-plug-in vereist Android Studio 3.1 of hoger. Als u niet zeker weet welke versie van Android Studio u gebruikt, selecteert u 'Android Studio> Over Android Studio' op de werkbalk. De volgende pop-up bevat basisinformatie over uw Android Studio-installatie, inclusief het versienummer.

Om de Sceneform-plug-in te installeren:

• Als u een Mac gebruikt, selecteert u "Android Studio> Voorkeuren ..." op de Android Studio-werkbalk en kiest u vervolgens "Plug-ins" in het menu aan de linkerkant. Als u een Windows-pc gebruikt, selecteert u "Bestand> Instellingen> Plug-ins> Doorzoek repositories."
• Zoek naar "Sceneform". Wanneer "Google Sceneform Tools" verschijnt, selecteert u "Installeren".
• Start Android Studio opnieuw wanneer daarom wordt gevraagd en uw plug-in is klaar voor gebruik.

Sceneform UX en Java 8: uw projectafhankelijkheden bijwerken

Laten we beginnen met het toevoegen van de afhankelijkheden die we in dit project zullen gebruiken. Open uw build.gradle-bestand op moduleniveau en voeg de Sceneform UX-bibliotheek toe, die het ArFragment bevat dat we in onze lay-out zullen gebruiken:

afhankelijkheden {implementatie fileTree (dir: libs, include:) implementatie androidx.appcompat: appcompat: 1.0.2 implementatie androidx.constraintlayout: constraintlayout: 1.1.3 test Implementatie junit: junit: 4.12 androidTestImplementatie androidx.test.ext: junit: 1.1.0 androidTestImplementation androidx.test.espresso: espresso-core: 3.1.1 // Sceneform UX biedt UX-bronnen, waaronder ArFragment // implementatie "com.google.ar.sceneform.ux: sceneform-ux: 1.7.0" implementatie "com. android.support:appcompat-v7:28.0.0 "}

Sceneform gebruikt taalconstructies van Java 8, dus we moeten ook de broncompatibiliteit en doelcompatibiliteit van ons project bijwerken naar Java 8:

compileOptions {sourceCompatibiliteit JavaVersion.VERSION_1_8 targetCompatibiliteit JavaVersion.VERSION_1_8}

Tot slot moeten we de Sceneform-plug-in toepassen:

plugin toepassen: com.google.ar.sceneform.plugin

Uw voltooide build.gradle-bestand zou er ongeveer zo uit moeten zien:

plugin toepassen: com.android.application android {compileSdkVersion 28 defaultConfig {applicationId "com.jessicathornsby.arcoredemo" minSdkVersion 23 targetSdkVersion 28 versionCode 1 versionName "1.0" testInstrumentationRunner "androidx.Test.Rest.Rest.Rest.Unl JavaVersion.VERSION_1_8} buildTypes {release {minifyEnabled valse proguardFiles getDefaultProguardFile (proguard-android-optimal.txt), proguard-rules.pro}}} afhankelijkheden {implementatie fileTree (dir: libs, include:) implementatie androidx.appcompat: appcompat: 1.0 Compatibel .2 implementatie androidx.constraintlayout: constraintlayout: 1.1.3 testImplementatie junit: junit: 4.12 androidTestImplementatie androidx.test.ext: junit: 1.1.0 androidTestImplementatie androidx.test.espresso: espresso-core: 3.1.1 implementatie "com.google. ar.sceneform.ux: sceneform-ux: 1.7.0 "implementatie" com.android.support:appcompat-v7:28.0.0 "} plug-in toepassen: com.google.ar .sceneform.plugin

Toestemmingen aanvragen met ArFragment

Onze applicatie gebruikt de camera van het apparaat om de omgeving te analyseren en 3D-modellen in de echte wereld te positioneren. Voordat onze applicatie toegang heeft tot de camera, heeft deze de cameratoestemming nodig, dus open het Manifest van uw project en voeg het volgende toe:

Android 6.0 gaf gebruikers de mogelijkheid om machtigingen per machtiging te verlenen, te weigeren en in te trekken. Hoewel dit de gebruikerservaring verbeterde, moeten Android-ontwikkelaars nu tijdens de runtime handmatig machtigingen aanvragen en de reactie van de gebruiker verwerken. Het goede nieuws is dat bij het werken met Google ARCore het proces van het aanvragen van de cameratoestemming en het verwerken van de reactie van de gebruiker is geïmplementeerd automatisch.

De component ArFragment controleert automatisch of uw app de cameramachtiging heeft en vraagt ​​deze vervolgens, indien nodig, aan voordat de AR-sessie wordt gemaakt. Omdat we ArFragment in onze app zullen gebruiken, hoeven we geen code te schrijven om de cameratoestemming aan te vragen.

AR Vereist of optioneel?

Er zijn twee soorten applicaties die AR-functionaliteit gebruiken:

1. AR vereist

Als uw applicatie afhankelijk is van Google ARCore om een ​​goede gebruikerservaring te bieden, moet u ervoor zorgen dat deze alleen wordt gedownload naar apparaten die ARCore ondersteunen. Als u uw app markeert als 'AR vereist', wordt deze alleen weergegeven in de Google Play Store als het apparaat ARCore ondersteunt.

Sinds onze applicatie doet vereist ARCore, open het manifest en voeg het volgende toe:

Er is ook een kans dat uw toepassing wordt gedownload naar een apparaat dat in theorie ARCore ondersteunt, maar ARCore niet heeft geïnstalleerd. Zodra we onze app als 'AR vereist' markeren, downloadt en installeert Google Play automatisch ARCore naast uw app, als deze nog niet aanwezig is op het doelapparaat.

Houd er rekening mee dat zelfs als uw app Android is: vereist = "waar" u dat zult doen nog steeds moeten controleren of ARCore aanwezig is tijdens runtime, omdat de kans bestaat dat de gebruiker ARCore heeft verwijderd sinds het downloaden van uw app, of dat hun versie van ARCore verouderd is.

Het goede nieuws is dat we ArFragment gebruiken, dat automatisch controleert of ARCore is geïnstalleerd en up-to-date is voordat het wordt gemaakt elk AR-sessie - nogmaals, dit is iets dat we niet handmatig hoeven te implementeren.

2. AR Optioneel

Als uw app AR-functies bevat die prettig zijn, maar niet essentieel voor het leveren van de kernfunctionaliteit, kunt u deze applicatie markeren als "AR Optioneel". Uw app kan vervolgens controleren of Google ARCore aanwezig is tijdens runtime en de AR-functies op apparaten die ARCore niet ondersteunen.

Als u een app "AR Optioneel" maakt, doet ARCore dat niet automatisch worden geïnstalleerd naast uw toepassing, zelfs als het apparaat alle hardware en software heeft die nodig is om ARCore te ondersteunen. Uw app "AR Optioneel" moet dan controleren of ARCore aanwezig en up-to-date is en de nieuwste versie downloaden als dat nodig is.

Als ARCore niet cruciaal is voor uw app, kunt u het volgende toevoegen aan uw manifest:

Hoewel ik de Manifest open heb, voeg ik ook android: configChanges en android: screenOrientation toe, om te zorgen dat MainActivity de oriëntatiewijzigingen netjes afhandelt.

Nadat je dit alles aan je manifest hebt toegevoegd, zou het voltooide bestand er ongeveer zo uit moeten zien:

Voeg ArFragment toe aan uw lay-out

Ik gebruik ARCore's ArFragment, omdat het automatisch een aantal belangrijke ARCore-taken afhandelt aan het begin van elke AR-sessie. Het meest opvallend is dat ArFragment controleert of een compatibele versie van ARCore op het apparaat is geïnstalleerd en dat de app momenteel de cameramachtiging heeft.

Zodra ArFragment heeft geverifieerd dat het apparaat de AR-functies van uw app kan ondersteunen, maakt het een ArSceneView ARCore-sessie en is de AR-ervaring van uw app klaar voor gebruik!

U kunt het ArFragment-fragment aan een lay-outbestand toevoegen, net als een normaal Android-fragment, dus open uw activity_main.xml-bestand en voeg een component "com.google.ar.sceneform.ux.ArFragment" toe.

3D-modellen downloaden met behulp van de Poly van Google

Er zijn verschillende manieren waarop u Renderables kunt maken, maar in dit artikel gebruiken we een 3D-activabestand.

Sceneform ondersteunt 3D-middelen in .OBJ-, .glTF- en .FBX-formaten, met of zonder animaties. Er zijn veel plaatsen waar u 3D-modellen kunt aanschaffen in een van deze ondersteunde indelingen, maar in deze zelfstudie gebruik ik een .OBJ-bestand, gedownload van de Poly-repository van Google.

Ga naar de Poly-website en download het item dat je wilt gebruiken, in .OBJ-formaat (ik gebruik dit T-Rex-model).

• Pak de map uit, die het bronbestand van uw model (.OBJ, .FBX of .glTF) moet bevatten. Afhankelijk van het model kan deze map ook enkele modelafhankelijkheden bevatten, zoals bestanden in de indelingen .mtl, .bin, .png of .jpeg.

3D-modellen importeren in Android Studio

Als u eenmaal uw item hebt, moet u het in Android Studio importeren met behulp van de Sceneform-plug-in. Dit is een uit meerdere stappen bestaand proces waarbij u:

• Maak een map "sampledata". Sampledata is een nieuw maptype voor voorbeeldtijdgegevens van het ontwerp dat niet wordt opgenomen in uw APK, maar beschikbaar zal zijn in de Android Studio-editor.
• Sleep het originele .OBJ-activabestand naar uw map "sampledata".
• Voer de Sceneform-import en -conversie uit op het .OBJ-bestand, dat de .sfa- en .sfb-bestanden genereert.

Hoewel het misschien eenvoudiger lijkt, niet doen sleep het .OBJ-bestand rechtstreeks naar de map 'res' van uw project, omdat het model hierdoor onnodig in uw APK wordt opgenomen.

Android Studio-projecten bevatten standaard geen map 'sampledata', dus u moet er handmatig een maken:

• Houd Control ingedrukt en klik op de map 'app' van uw project.
• Selecteer "Nieuw> Voorbeeldgegevensmap" en maak een map met de naam "sampledata".
• Navigeer naar de 3D-modelbestanden die u eerder hebt gedownload. Zoek het bronbestand (.OBJ, .FBX of .glTF) en sleep het naar de map "sampledata".
• Controleer of uw model afhankelijkheden heeft (zoals bestanden in de indelingen .mtl, .bin, .png of .jpeg). Als u een van deze bestanden aantreft, sleept u ze naar de map 'sampledata'.
• Klik in Android Studio op Control en klik op het bronbestand van uw 3D-model (.OBJ, .FBX of .glTF) en selecteer vervolgens "Sceneform Asset importeren".

• Het volgende venster toont wat informatie over de bestanden die Sceneform gaat genereren, inclusief waar het resulterende .sfa-bestand zal worden opgeslagen in uw project; Ik ga de map 'Raw' gebruiken.
• Als u tevreden bent met de informatie die u heeft ingevoerd, klikt u op 'Voltooien'.

Deze import brengt enkele wijzigingen aan in uw project. Als u uw build.gradle-bestand opent, ziet u dat de Sceneform-plug-in is toegevoegd als projectafhankelijkheid:

afhankelijkheden {classpath com.android.tools.build:gradle:3.5.0-alpha06 classpath com.google.ar.sceneform: plug-in: 1.7.0 // OPMERKING: plaats hier niet de afhankelijkheden van uw toepassing; ze horen // in de afzonderlijke module build.gradle-bestanden}}

Open uw build.gradle-bestand op moduleniveau en u zult een nieuw item sceneform.asset () vinden voor uw geïmporteerde 3D-model:

plugin toepassen: com.google.ar.sceneform.plugin // Het 'Bronbestandspad' dat u tijdens import hebt opgegeven // sceneform.asset (sampledata / dinosaur.obj, // Het 'Materiaalpad' dat u tijdens import heeft opgegeven // Standaard , // Het ".sfa-uitvoerpad" dat u tijdens het importeren hebt opgegeven // sampledata / dinosaur.sfa, // Het ".sfb-uitvoerpad" dat u tijdens het importeren hebt opgegeven // src / main / assets / dinosaur)

Als u uw "sampledata" en "raw" -mappen bekijkt, ziet u dat deze respectievelijk nieuwe .sfa- en .sfb-bestanden bevatten.

U kunt een voorbeeld van het .sfa-bestand bekijken in de nieuwe Sceneform Viewer van Android Studio:

• Selecteer "Beeld> Extra Windows> Viewer" in de menubalk van Android Studio.
• Selecteer uw .sfa-bestand in het linkermenu. Uw 3D-model zou nu in het Viewer-venster moeten verschijnen.

Geef uw 3D-model weer

Onze volgende taak is het maken van een AR-sessie die de omgeving begrijpt en waarmee de gebruiker 3D-modellen in een uitgebreide scène kan plaatsen.

Dit vereist dat wij het volgende doen:

1. Maak een ArFragment-lidvariabele

De ArFragment voert een groot deel van het zware werk uit dat gepaard gaat met het maken van een AR-sessie, dus we zullen naar dit fragment verwijzen in onze MainActivity-klasse.

In het volgende fragment maak ik een lidvariabele voor ArFragment en initialiseer ik deze vervolgens in de methode onCreate ():

privé ArFragment arCoreFragment; @Override beschermde nietig onCreate (bundle saveInstanceState) {super.onCreate (saveInstanceState); ... ... ...} setContentView (R.layout.activity_main); arCoreFragment = (ArFragment) // Zoek het fragment met behulp van de fragmentmanager // getSupportFragmentManager (). findFragmentById (R.id.main_fragment);

2. Bouw een ModelRenderable

We moeten nu ons .sfb-bestand omzetten in een ModelRenderable, dat uiteindelijk ons ​​3D-object zal renderen.

Hier maak ik een ModelRenderable uit het res / raw / dinosaur .sfb-bestand van mijn project:

privé ModelRenderable dinoRenderable; ... ... ... ModelRenderable.builder () .setSource (this, R.raw.dinosaur) .build () .thenAccept (renderable -> dinoRenderable = renderable) .exceptionally (throwable -> {Log.e ( TAG, "Kan renderable niet laden"); return null;}); }

3. Reageren op gebruikersinvoer

ArFragment heeft ingebouwde ondersteuning voor tikken, slepen, knijpen en draaien.

In onze app voegt de gebruiker een 3D-model toe aan een ARCore-vliegtuig door dat vliegtuig een tik te geven.

Om deze functionaliteit te leveren, moeten we een callback registreren die wordt geactiveerd wanneer op een vliegtuig wordt getikt:

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

4. Veranker uw model

In deze stap gaan we een ArSceneView ophalen en koppelen aan een AnchorNode, die zal fungeren als het bovenliggende knooppunt van de Scene.

De ArSceneView is verantwoordelijk voor het uitvoeren van verschillende belangrijke ARCore-taken, waaronder het weergeven van de camerabeelden van het apparaat en het weergeven van een Sceneform UX-animatie die laat zien hoe de gebruiker zijn apparaat moet vasthouden en verplaatsen om de AR-ervaring te starten. De ArSceneView markeert ook alle vlakken die worden gedetecteerd, klaar voor de gebruiker om zijn 3D-modellen in de scène te plaatsen.

Aan de ARSceneView-component is een scène gekoppeld, wat een ouder-kind gegevensstructuur is die alle knooppunten bevat die moeten worden weergegeven.

We gaan beginnen met het maken van een knooppunt van het type AnchorNode, dat zal fungeren als het bovenliggende knooppunt van onze ArSceneView.

Alle ankerknopen blijven in dezelfde positie in de echte wereld, dus door een ankerknooppunt te creëren, zorgen we ervoor dat onze 3D-modellen binnen de vergrote scène op hun plaats blijven.

Laten we onze ankerknoop maken:

AnchorNode anchorNode = nieuw AnchorNode (anker);

We kunnen vervolgens een ArSceneView ophalen met behulp van getArSceneView () en deze koppelen aan de AnchorNode:

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

5. Ondersteuning toevoegen voor verplaatsen, schalen en roteren

Vervolgens ga ik een knooppunt maken van het type TransformableNode. De TransformableNode is verantwoordelijk voor het verplaatsen, schalen en roteren van knooppunten, op basis van gebruikersgebaren.

Nadat u een TransformableNode hebt gemaakt, kunt u deze de Renderable koppelen, waarmee het model kan worden geschaald en verplaatst op basis van gebruikersinteractie. Ten slotte moet u de TransformableNode verbinden met de AnchorNode, in een kind-ouderrelatie die zorgt voor de TransformableNode en Renderable blijft op zijn plaats binnen de vergrote scène.

TransformableNode transformableNode = nieuw TransformableNode (arCoreFragment.getTransformationSystem ()); // Verbind transformableNode met anchorNode // transformableNode.setParent (anchorNode); transformableNode.setRenderable (dinoRenderable); // Selecteer het knooppunt // transformableNode.select (); }); }

De voltooide MainActivity

Nadat u al het bovenstaande hebt uitgevoerd, zou uw MainActivity er ongeveer zo uit moeten zien:

android.app.Activity importeren; android.app.ActivityManager importeren; androidx.appcompat.app.AppCompatActivity importeren; android.content.Context importeren; android.net.Uri importeren; android.os importeren. android.os.Build.VERSION_CODES importeren; android.os.bundle importeren; android.util.Log importeren; android.view.MotionEvent importeren; androidx.annotation.RequiresApi importeren; 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; openbare klasse MainActivity breidt AppCompatActivity {private statische finale String TAG = MainActivity.class.getSimpleName (); privé statische finale dubbel MIN_OPENGL_VERSION = 3.0; // Maak een lidvariabele voor ModelRenderable // private ModelRenderable dinoRenderable; // Maak een lidvariabele voor ArFragment // private ArFragment arCoreFragment; @RequiresApi (api = VERSION_CODES.N) @Override beveiligde ongeldige onCreate (bundle saveInstanceState) {super.onCreate (saveInstanceState); if (! checkDevice ((this)))) {retour; } setContentView (R.layout.activity_main); arCoreFragment = (ArFragment) // Zoek het fragment met fragmentmanager // getSupportFragmentManager (). findFragmentById (R.id.main_fragment); if (Build.VERSION.SDK_INT> = VERSION_CODES.N) {// Bouw de ModelRenderable // ModelRenderable.builder () .setSource (this, R.raw.dinosaur) .build () .thenAccept (renderbaar -> dinoRenderable = renderable ) .uitzonderlijk (// Als er een fout optreedt ... // gooibaar -> {//... druk dan het volgende af naar Logcat // Log.e (TAG, "Kan renderbaar niet laden"); retourneer null;} ); } // Luister naar onTap-evenementen // arCoreFragment.setOnTapArPlaneListener ((HitResult hitResult, Plane plane, MotionEvent motionEvent) -> {if (dinoRenderable == null) {return;} Anchor anchor = hitResult.createAnchor (); // Build a knooppunt van het type AnchorNode // AnchorNode anchorNode = new AnchorNode (anker); // Verbind de AnchorNode met de Scene // anchorNode.setParent (arCoreFragment.getArSceneView (). getScene ()); // Bouw een knooppunt van het type TransformableNode // TransformableNode transformableNode = new TransformableNode (arCoreFragment.getTransformationSystem ()); // Verbind de TransformableNode met de AnchorNode // transformableNode.setParent (anchorNode); // Bevestig de Renderable // transformableNode.setRenderable (dinoRenderable); // Stel de node in / / transformableNode.select ();}); } public static boolean checkDevice (final Activity activity) {// Als op het apparaat Android Marshmallow of eerder wordt uitgevoerd ... // if (Build.VERSION.SDK_INT <VERSION_CODES.N) {//... druk dan het volgende af naar Logcat // Log.e (TAG, "Sceneform vereist Android N of hoger"); activity.finish (); return false; } String openGlVersionString = (((ActivityManager) activity.getSystemService (Context.ACTIVITY_SERVICE)) .getDeviceConfigurationInfo () // Controleer de versie van OpenGL ES // .getGlEsVersion (); // Als het apparaat iets minder dan OpenGL ES 3.0 uitvoert ... // if (Double.parseDouble (openGlVersionString) <MIN_OPENGL_VERSION) {//... druk het volgende af naar Logcat // Log.e (TAG, " Vereist OpenGL ES 3.0 of hoger "); activity.finish (); return false; } terug waar; }}

Je kunt het voltooide project downloaden van GitHub.

Uw Google ARCore augmented reality-app testen

U bent nu klaar om uw app te testen op een fysiek, ondersteund Android-apparaat. Als je geen apparaat hebt dat ARCore ondersteunt, is het mogelijk om je AR-app te testen in de Android Emulator (met een beetje extra configuratie, die we in het volgende gedeelte zullen bespreken).

Om uw project te testen op een fysiek Android-apparaat:

• Installeer uw applicatie op het doelapparaat.
• Verleent de toepassing toegang tot de camera van uw apparaat wanneer daarom wordt gevraagd.
• Als u wordt gevraagd om de ARCore-app te installeren of bij te werken, tikt u op "Doorgaan" en voltooit u het dialoogvenster om te controleren of u de nieuwste en beste versie van ARCore gebruikt.
• U zou nu een cameraweergave moeten zien, compleet met een animatie van een hand die een apparaat vasthoudt. Richt de camera op een vlak oppervlak en beweeg uw apparaat in een cirkelvormige beweging, zoals blijkt uit de animatie. Na enkele ogenblikken moet een reeks punten verschijnen die aangeven dat een vlak is gedetecteerd.

• Als u eenmaal tevreden bent met de positie van deze stippen, tikt u erop - uw 3D-model zou nu op uw gekozen vlak moeten verschijnen!

• Probeer fysiek rond het model te bewegen; afhankelijk van je omgeving kun je de volledige 360 ​​graden eromheen doen. Je moet ook controleren of het object een schaduw werpt die consistent is met de echte lichtbronnen.

ARCore testen op een virtueel Android-apparaat

Als u uw ARCore-apps wilt testen in een Android Virtual Device (AVD), hebt u Android Emulator-versie 27.2.9 of hoger nodig. U moet ook zijn aangemeld bij de Google Play Store op uw AVD en OpenGL ES 3.0 of hoger hebben ingeschakeld.

Om te controleren of OpenGL ES 3.0 of hoger momenteel is ingeschakeld op uw AVD:

• Start uw AVD zoals normaal.
• Open een nieuw Terminal-venster (Mac) of een opdrachtprompt (Windows).
• Wijzig de map ('cd') zodat de Terminal / Command Prompt naar de locatie van het 'adb'-programma van uw Android SDK wijst, mijn opdracht ziet er bijvoorbeeld als volgt uit:

Cd / Gebruikers / jessicathornsby / Bibliotheek / Android / sdk / platform-tools

• Druk op de Enter-toets op uw toetsenbord.
• Kopieer / plak de volgende opdracht in de terminal en druk vervolgens op de toets "Enter":

./adb logcat | grep eglMakeCurrent

Als de Terminal "ver 3 0" of hoger retourneert, is OpenGL ES correct geconfigureerd. Als de terminal of opdrachtprompt iets eerder dan 3.0 weergeeft, moet u OpenGL ES 3.0 inschakelen:

• Schakel terug naar uw AVD.
• Zoek de strook met "Uitgebreide bediening" -knoppen die naast de Android-emulator zweven en selecteer vervolgens "Instellingen> Geavanceerd".
• Navigeer naar "OpenGL ES API-niveau> Renderer maximum (tot OpenGL ES 3.1)."
• Start de emulator opnieuw.

Kopieer / plak in het venster Terminal / opdrachtprompt de volgende opdracht en druk vervolgens op de toets "Enter"

./adb logcat | grep eglMakeCurrent

U zou nu een resultaat van "ver 3 0" of hoger moeten krijgen, wat betekent dat OpenGL ES correct is geconfigureerd.

Zorg er ten slotte voor dat uw AVD de nieuwste versie van ARCore gebruikt:

• Ga naar de GitHub-pagina van ARCore en download de nieuwste versie van ARCore voor de emulator. Op het moment van schrijven was de meest recente versie bijvoorbeeld "ARCore_1.7.0.x86_for_emulator.apk"
• Sleep de APK naar uw actieve AVD.

Om uw project op een AVD te testen, installeert u uw toepassing en verleent u deze toegang tot de "camera" van de AVD wanneer daarom wordt gevraagd.

U zou nu een cameraweergave van een gesimuleerde ruimte moeten zien. Om uw toepassing te testen, beweegt u door deze virtuele ruimte, zoekt u een gesimuleerd vlak oppervlak en klikt u om een ​​model op dit oppervlak te plaatsen.

U kunt de virtuele camera door de virtuele kamer verplaatsen door de toetsen "Option" (macOS) of "Alt" (Linux of Windows) ingedrukt te houden en vervolgens een van de volgende sneltoetsen te gebruiken:

• Beweeg naar links of rechts. Druk op A of D.
• Ga naar beneden of naar boven. Druk op Q of E.
• Vooruit of achteruit gaan. Druk op W of S.

U kunt ook door de virtuele scène "bewegen" door op "Optie" of "Alt" te drukken en vervolgens uw muis te gebruiken. Dit kan in het begin een beetje onhandig aanvoelen, maar met oefening zou je de virtuele ruimte met succes moeten kunnen verkennen. Zodra u een gesimuleerd vlak hebt gevonden, klikt u op de witte stippen om uw 3D-model op dit oppervlak te plaatsen.

Afsluiten

In dit artikel hebben we een eenvoudige augmented reality-app gemaakt met ARCore en de Sceneform-plug-in.

Als je besluit Google ARCore in je eigen projecten te gebruiken, deel je creaties dan in de reacties hieronder!