Inhalt

• Importieren von 3D-Modellen mit dem Sceneform-Plugin
• Installation des Sceneform-Plugins
• Sceneform UX und Java 8: Aktualisieren Ihrer Projektabhängigkeiten
• Anfordern von Berechtigungen mit ArFragment
• AR erforderlich oder optional?
• 1. AR erforderlich
• 2. AR Optional
• Fügen Sie Ihrem Layout ArFragment hinzu
• Herunterladen von 3D-Modellen mithilfe von Google Poly
• Importieren von 3D-Modellen in Android Studio
• Zeigen Sie Ihr 3D-Modell an
• 1. Erstellen Sie eine ArFragment-Mitgliedsvariable
• 2. Erstellen Sie ein ModelRenderable
• 3. Reagieren Sie auf Benutzereingaben
• 4. Verankern Sie Ihr Modell
• 5. Unterstützung für Verschieben, Skalieren und Drehen hinzufügen
• Die abgeschlossene MainActivity
• Testen Sie Ihre Google ARCore Augmented Reality-App
• Testen von ARCore auf einem virtuellen Android-Gerät
• Einpacken

Importieren von 3D-Modellen mit dem Sceneform-Plugin

Normalerweise erfordert das Arbeiten mit 3D-Modellen Fachkenntnisse. Mit der Veröffentlichung des Sceneform-Plugins hat Google es jedoch möglich gemacht, 3D-Modelle mit Java zu rendern - und ohne OpenGL lernen zu müssen.

Das Sceneform-Plugin bietet eine API auf hoher Ebene, mit der Sie Renderdateien aus Standard-Android-Widgets, -Formen oder -Materialien oder aus 3D-Elementen wie OBJ- oder FBX-Dateien erstellen können.

In unserem Projekt wird das Sceneform-Plugin zum Importieren einer OBJ-Datei in Android Studio verwendet. Wann immer Sie eine Datei mit Sceneform importieren, wird dieses Plugin automatisch:

• Konvertieren Sie die Asset-Datei in eine .sfb-Datei. Dies ist ein laufzeitoptimiertes Sceneform-Binärformat (.sfb), das zu Ihrer APK hinzugefügt und dann zur Laufzeit geladen wird. Wir werden diese .sfb-Datei verwenden, um ein Renderable zu erstellen, das aus Maschen, Materialien und Texturen besteht und an einer beliebigen Stelle in der erweiterten Szene platziert werden kann.
• Generieren Sie eine .sfa-Datei. Dies ist eine Asset-Beschreibungsdatei, bei der es sich um eine Textdatei handelt, die eine lesbare Beschreibung der SFB-Datei enthält. Je nach Modell können Sie möglicherweise das Erscheinungsbild ändern, indem Sie den Text in der .sfa-Datei bearbeiten.

Beachten Sie jedoch, dass sich das Sceneform-Plugin zum Zeitpunkt des Schreibens noch in der Betaphase befand, sodass es bei der Verwendung dieses Plugins zu Fehlern, Fehlern oder anderem merkwürdigem Verhalten kommen kann.

Installation des Sceneform-Plugins

Das Sceneform-Plugin erfordert Android Studio 3.1 oder höher. Wenn Sie sich nicht sicher sind, welche Version von Android Studio Sie verwenden, wählen Sie in der Symbolleiste "Android Studio> Über Android Studio". Das folgende Popup enthält einige grundlegende Informationen zu Ihrer Android Studio-Installation, einschließlich der Versionsnummer.

So installieren Sie das Sceneform-Plugin:

• Wenn Sie einen Mac verwenden, wählen Sie in der Android Studio-Symbolleiste "Android Studio> Einstellungen ..." und dann im linken Menü "Plugins". Wenn Sie sich auf einem Windows-PC befinden, wählen Sie "Datei> Einstellungen> Plugins> Repositorys durchsuchen".
• Suchen Sie nach "Sceneform". Wenn "Google Sceneform Tools" angezeigt wird, wählen Sie "Installieren".
• Starten Sie Android Studio neu, wenn Sie dazu aufgefordert werden, und Ihr Plugin ist einsatzbereit.

Sceneform UX und Java 8: Aktualisieren Ihrer Projektabhängigkeiten

Beginnen wir mit dem Hinzufügen der Abhängigkeiten, die wir in diesem Projekt verwenden werden. Öffnen Sie Ihre build.gradle-Datei auf Modulebene und fügen Sie die Sceneform UX-Bibliothek hinzu, die das ArFragment enthält, das wir in unserem Layout verwenden werden:

Abhängigkeiten {Implementierung fileTree (dir: libs, include:) Implementierung androidx.appcompat: appcompat: 1.0.2 Implementierung 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 // Sceneform UX stellt UX-Ressourcen bereit, einschließlich ArFragment // Implementierung "com.google.ar.sceneform.ux: sceneform-ux: 1.7.0" Implementierung "com. android.support:appcompat-v7:28.0.0 "}

Sceneform verwendet Sprachkonstrukte aus Java 8. Daher müssen wir auch die Quell- und Zielkompatibilität unseres Projekts auf Java 8 aktualisieren:

compileOptions {sourceCompatibility JavaVersion.VERSION_1_8 targetCompatibility JavaVersion.VERSION_1_8}

Schließlich müssen wir das Sceneform-Plugin anwenden:

Plugin anwenden: com.google.ar.sceneform.plugin

Ihre fertige build.gradle-Datei sollte ungefähr so ​​aussehen:

Plugin anwenden: com.android.application android {compileSdkVersion 28 defaultConfig {applicationId "com.jessicathornsby.arcoredemo" minSdkVersion 23 targetSdkVersion 28 versionCode 1 versionName "1.0" testInstrumentationRunner "androidx.test.runner.Android_Vers_junner_sourceUnit JavaVersion.VERSION_1_8} buildTypes {release {minifyEnabled false proguardFiles getDefaultProguardFile (proguard-android-Optimize.txt), proguard-rules.pro}}} Abhängigkeiten {Implementation fileTree (dir: libs, include:) Implementierung androidx.appcompat: 1.0 .2 implementierung 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 implementierung "com.google. ar.sceneform.ux: sceneform-ux: 1.7.0 "Implementierung" com.android.support:appcompat-v7:28.0.0 "} Plugin anwenden: com.google.ar .sceneform.plugin

Anfordern von Berechtigungen mit ArFragment

Unsere Anwendung wird die Kamera des Geräts verwenden, um seine Umgebung zu analysieren und 3D-Modelle in der realen Welt zu positionieren. Bevor unsere Anwendung auf die Kamera zugreifen kann, ist eine Kameraberechtigung erforderlich. Öffnen Sie daher das Manifest Ihres Projekts und fügen Sie Folgendes hinzu:

Mit Android 6.0 konnten Benutzer Berechtigungen für jede Berechtigung einzeln erteilen, verweigern und widerrufen. Während dies die Benutzerfreundlichkeit verbesserte, müssen Android-Entwickler nun zur Laufzeit manuell Berechtigungen anfordern und die Antwort des Benutzers verarbeiten. Die gute Nachricht ist, dass bei der Arbeit mit Google ARCore das Anfordern der Kameraerlaubnis und das Verarbeiten der Benutzerantwort implementiert ist automatisch.

Die ArFragment-Komponente überprüft automatisch, ob Ihre App über die Kameraberechtigung verfügt, und fordert diese bei Bedarf an, bevor die AR-Sitzung erstellt wird. Da wir ArFragment in unserer App verwenden, müssen wir keinen Code schreiben, um die Kameraerlaubnis anzufordern.

AR erforderlich oder optional?

Es gibt zwei Arten von Anwendungen, die die AR-Funktionalität verwenden:

1. AR erforderlich

Wenn Ihre Anwendung auf Google ARCore angewiesen ist, um eine gute Nutzererfahrung zu erzielen, müssen Sie sicherstellen, dass sie nur auf Geräte heruntergeladen wird, die ARCore unterstützen. Wenn Sie Ihre App als "AR erforderlich" markieren, wird sie nur im Google Play Store angezeigt, wenn das Gerät ARCore unterstützt.

Seit unserer Bewerbung tut Benötigen Sie ARCore, öffnen Sie das Manifest und fügen Sie Folgendes hinzu:

Es besteht auch die Möglichkeit, dass Ihre Anwendung auf ein Gerät heruntergeladen wird, das ARCore theoretisch unterstützt, auf dem ARCore jedoch nicht installiert ist. Sobald wir unsere App als "AR erforderlich" markieren, lädt Google Play automatisch ARCore herunter und installiert es zusammen mit Ihrer App, sofern es nicht bereits auf dem Zielgerät vorhanden ist.

Beachten Sie jedoch, dass Sie auch dann, wenn Ihre App ein Android-Gerät ist: Erforderlich = "wahr" immer noch Sie müssen überprüfen, ob ARCore zur Laufzeit vorhanden ist, da der Benutzer möglicherweise ARCore deinstalliert hat, seit er Ihre App heruntergeladen hat, oder ob seine Version von ARCore nicht mehr aktuell ist.

Die gute Nachricht ist, dass wir ArFragment verwenden, das vor dem Erstellen automatisch überprüft, ob ARCore installiert und auf dem neuesten Stand ist jeder AR-Sitzung - dies muss also erneut nicht manuell implementiert werden.

2. AR Optional

Wenn Ihre App über nützliche AR-Funktionen verfügt, die für die Bereitstellung der Kernfunktionalität jedoch nicht unbedingt erforderlich sind, können Sie diese Anwendung als "AR-optional" kennzeichnen. Ihre App kann dann überprüfen, ob Google ARCore zur Laufzeit vorhanden ist, und diese deaktivieren AR-Funktionen auf Geräten, die ARCore nicht unterstützen.

Wenn Sie eine "AR Optional" -App erstellen, wird ARCore nicht werden automatisch zusammen mit Ihrer Anwendung installiert, auch wenn das Gerät über die gesamte Hardware und Software verfügt, die zur Unterstützung von ARCore erforderlich ist. Ihre App "AR Optional" muss dann prüfen, ob ARCore vorhanden und auf dem neuesten Stand ist, und bei Bedarf die neueste Version herunterladen.

Wenn ARCore für Ihre App nicht entscheidend ist, können Sie Ihrem Manifest Folgendes hinzufügen:

Während das Manifest geöffnet ist, füge ich auch android: configChanges und android: screenOrientation hinzu, um sicherzustellen, dass MainActivity Änderungen der Ausrichtung ordnungsgemäß handhabt.

Nachdem Sie dies alles zu Ihrem Manifest hinzugefügt haben, sollte die fertige Datei ungefähr so ​​aussehen:

Fügen Sie Ihrem Layout ArFragment hinzu

Ich verwende ARCores ArFragment, da es zu Beginn jeder AR-Sitzung automatisch eine Reihe wichtiger ARCore-Aufgaben erledigt. Insbesondere überprüft ArFragment, ob eine kompatible Version von ARCore auf dem Gerät installiert ist und ob die App derzeit über die Kameraberechtigung verfügt.

Sobald ArFragment überprüft hat, dass das Gerät die AR-Funktionen Ihrer App unterstützt, erstellt es eine ArSceneView ARCore-Sitzung und die AR-Erfahrung Ihrer App ist einsatzbereit!

Sie können das ArFragment-Fragment wie ein normales Android-Fragment zu einer Layout-Datei hinzufügen. Öffnen Sie also Ihre activity_main.xml-Datei und fügen Sie eine Komponente "com.google.ar.sceneform.ux.ArFragment" hinzu.

Herunterladen von 3D-Modellen mithilfe von Google Poly

Sie können Renderables auf verschiedene Arten erstellen. In diesem Artikel wird jedoch eine 3D-Asset-Datei verwendet.

Sceneform unterstützt 3D-Elemente in den Formaten OBJ, GLTF und FBX mit oder ohne Animationen. Es gibt viele Orte, an denen Sie 3D-Modelle in einem dieser unterstützten Formate erwerben können. In diesem Lernprogramm verwende ich jedoch eine OBJ-Datei, die aus dem Poly-Repository von Google heruntergeladen wurde.

Besuchen Sie die Poly-Website und laden Sie das gewünschte Asset im OBJ-Format herunter (ich verwende dieses T-Rex-Modell).

• Entpacken Sie den Ordner, der die Quell-Asset-Datei Ihres Modells enthalten soll (.OBJ, .FBX oder .glTF). Je nach Modell enthält dieser Ordner möglicherweise auch einige Modellabhängigkeiten, z. B. Dateien in den Formaten .mtl, .bin, .png oder .jpeg.

Importieren von 3D-Modellen in Android Studio

Sobald Sie Ihr Asset haben, müssen Sie es mit dem Sceneform-Plugin in Android Studio importieren. Dies ist ein mehrstufiger Prozess, der Folgendes erfordert:

• Erstellen Sie einen Sampledata-Ordner. Sampledata ist ein neuer Ordnertyp für Musterdaten zur Entwurfszeit, die nicht in Ihrem APK enthalten sind, aber im Android Studio-Editor verfügbar sind.
• Ziehen Sie die ursprüngliche OBJ-Asset-Datei in Ihren Ordner "sampledata" und legen Sie sie dort ab.
• Führen Sie den Import und die Konvertierung von Sceneform für die OBJ-Datei aus, wodurch die SFA- und SFB-Dateien generiert werden.

Obwohl es einfacher zu sein scheint, nicht Ziehen Sie die OBJ-Datei per Drag & Drop direkt in das res-Verzeichnis Ihres Projekts, da dies dazu führt, dass das Modell unnötigerweise in Ihr APK aufgenommen wird.

Android Studio-Projekte enthalten standardmäßig keinen Sampledata-Ordner. Daher müssen Sie einen manuell erstellen:

• Klicken Sie bei gedrückter Ctrl-Taste auf den App-Ordner Ihres Projekts.
• Wählen Sie "Neu> Beispieldatenverzeichnis" und erstellen Sie einen Ordner mit dem Namen "Beispieldaten".
• Navigieren Sie zu den zuvor heruntergeladenen 3D-Modelldateien. Suchen Sie die Quell-Asset-Datei (.OBJ, .FBX oder .glTF) und ziehen Sie sie in das Verzeichnis "sampledata".
• Überprüfen Sie, ob Ihr Modell Abhängigkeiten aufweist (z. B. Dateien in den Formaten .mtl, .bin, .png oder .jpeg). Wenn Sie eine dieser Dateien finden, ziehen Sie sie in den Ordner "sampledata".
• Klicken Sie in Android Studio bei gedrückter Ctrl-Taste auf die Quelldatei Ihres 3D-Modells (.OBJ, .FBX oder .glTF) und wählen Sie dann „Sceneform-Asset importieren“.

• Das folgende Fenster zeigt einige Informationen zu den Dateien an, die Sceneform generieren wird, einschließlich des Speicherorts der resultierenden .sfa-Datei in Ihrem Projekt. Ich werde das "raw" -Verzeichnis verwenden.
• Wenn Sie mit den eingegebenen Informationen zufrieden sind, klicken Sie auf "Fertig stellen".

Dieser Import nimmt einige Änderungen an Ihrem Projekt vor. Wenn Sie Ihre build.gradle-Datei öffnen, sehen Sie, dass das Sceneform-Plugin als Projektabhängigkeit hinzugefügt wurde:

Abhängigkeiten {Klassenpfad com.android.tools.build:gradle:3.5.0-alpha06 Klassenpfad com.google.ar.sceneform: plugin: 1.7.0 // HINWEIS: Platzieren Sie Ihre Anwendungsabhängigkeiten nicht hier. sie gehören // in das einzelne Modul build.gradle files}}

Öffnen Sie Ihre build.gradle-Datei auf Modulebene und Sie finden einen neuen sceneform.asset () -Eintrag für Ihr importiertes 3D-Modell:

wende das Plugin an: com.google.ar.sceneform.plugin // Der beim Import festgelegte „Source Asset Path“ // sceneform.asset (sampledata / dinosaur.obj, // Der beim Import festgelegte „Material Path“ // Default , // Der ".sfa-Ausgabepfad", den Sie beim Import angegeben haben // sampledata / dinosaur.sfa, // Der ".sfb-Ausgabepfad", den Sie beim Import angegeben haben // src / main / assets / dinosaur)

Wenn Sie sich die Ordner "sampledata" und "raw" ansehen, werden Sie feststellen, dass sie neue .sfa- bzw. .sfb-Dateien enthalten.

Sie können eine Vorschau der .sfa-Datei in Android Studios neuem Sceneform Viewer anzeigen:

• Wählen Sie in der Android Studio-Menüleiste „Ansicht> Extras Windows> Viewer“.
• Wählen Sie im linken Menü Ihre .sfa-Datei aus. Ihr 3D-Modell sollte jetzt im Viewer-Fenster angezeigt werden.

Zeigen Sie Ihr 3D-Modell an

Unsere nächste Aufgabe besteht darin, eine AR-Sitzung zu erstellen, die die Umgebung versteht und es dem Benutzer ermöglicht, 3D-Modelle in einer erweiterten Szene zu platzieren.

Dazu müssen wir Folgendes tun:

1. Erstellen Sie eine ArFragment-Mitgliedsvariable

Das ArFragment leistet einen Großteil der Arbeit, die mit dem Erstellen einer AR-Sitzung verbunden ist. Daher verweisen wir in unserer MainActivity-Klasse auf dieses Fragment.

Im folgenden Snippet erstelle ich eine Mitgliedsvariable für ArFragment und initialisiere sie dann in der onCreate () -Methode:

private ArFragment arCoreFragment; @Override protected void onCreate (Bundle savedInstanceState) {super.onCreate (savedInstanceState); ... ... ...} setContentView (R.layout.activity_main); arCoreFragment = (ArFragment) // Suchen Sie das Fragment mit dem Fragment-Manager // getSupportFragmentManager (). findFragmentById (R.id.main_fragment);

2. Erstellen Sie ein ModelRenderable

Wir müssen jetzt unsere .sfb-Datei in eine ModelRenderable-Datei umwandeln, die schließlich unser 3D-Objekt rendert.

Hier erstelle ich ein ModelRenderable aus der res / raw / dinosaur .sfb-Datei meines Projekts:

private ModelRenderable dinoRenderable; ... ... ... ModelRenderable.builder () .setSource (this, R.raw.dinosaur) .build () .thenAccept (renderable -> dinoRenderable = renderable) .exceptionally (throwable -> {Log.e ( TAG, "Renderbar kann nicht geladen werden"; return null;}); }

3. Reagieren Sie auf Benutzereingaben

ArFragment unterstützt das Tippen, Ziehen, Kneifen und Drehen von Gesten.

In unserer App fügt der Benutzer einer ARCore-Ebene ein 3D-Modell hinzu, indem er diese Ebene antippt.

Um diese Funktionalität bereitzustellen, müssen wir einen Rückruf registrieren, der bei jedem Antippen eines Flugzeugs aufgerufen wird:

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

4. Verankern Sie Ihr Modell

In diesem Schritt rufen wir ein ArSceneView ab und hängen es an einen AnchorNode an, der als übergeordneter Knoten der Szene fungiert.

ArSceneView ist für die Ausführung mehrerer wichtiger ARCore-Aufgaben verantwortlich, einschließlich des Renderns der Kamerabilder des Geräts und der Anzeige einer Sceneform UX-Animation, die zeigt, wie der Benutzer sein Gerät halten und bewegen sollte, um die AR-Erfahrung zu starten. Das ArSceneView hebt auch alle erkannten Ebenen hervor, damit der Benutzer seine 3D-Modelle in der Szene platzieren kann.

An die ARSceneView-Komponente ist eine Szene angehängt, bei der es sich um eine Parent-Child-Datenstruktur handelt, die alle Knoten enthält, die gerendert werden müssen.

Zunächst erstellen wir einen Knoten vom Typ "AnchorNode", der als übergeordneter Knoten von ArSceneView fungiert.

Alle Ankerknoten bleiben an der gleichen Position in der realen Welt. Durch das Erstellen eines Ankerknotens stellen wir also sicher, dass unsere 3D-Modelle in der erweiterten Szene an ihrem Platz bleiben.

Erstellen wir unseren Ankerknoten:

AnchorNode anchorNode = new AnchorNode (Anker);

Anschließend können wir mit getArSceneView () eine ArSceneView abrufen und an den AnchorNode anhängen:

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

5. Unterstützung für Verschieben, Skalieren und Drehen hinzufügen

Als Nächstes werde ich einen Knoten vom Typ TransformableNode erstellen. Der TransformableNode ist für das Verschieben, Skalieren und Drehen von Knoten basierend auf Benutzergesten verantwortlich.

Nachdem Sie einen TransformableNode erstellt haben, können Sie ihn mit dem Renderable verknüpfen, damit das Modell basierend auf der Benutzerinteraktion skaliert und verschoben werden kann. Schließlich müssen Sie den TransformableNode mit dem AnchorNode in einer Kind-Eltern-Beziehung verbinden, die den TransformableNode sicherstellt und Renderable bleiben in der erweiterten Szene fixiert.

TransformableNode transformableNode = new TransformableNode (arCoreFragment.getTransformationSystem ()); // Verbinde transformableNode mit anchorNode // transformableNode.setParent (anchorNode); transformableNode.setRenderable (dinoRenderable); // wähle den Knoten // transformableNode.select (); }); }

Die abgeschlossene MainActivity

Nachdem Sie alle oben genannten Schritte ausgeführt haben, sollte Ihre MainActivity folgendermaßen aussehen:

android.app.Activity importieren; import android.app.ActivityManager; androidx.appcompat.app.AppCompatActivity importieren; android.content.Context importieren; 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; androidx.annotation.RequiresApi importieren; 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; Die öffentliche Klasse MainActivity erweitert AppCompatActivity {private static final String TAG = MainActivity.class.getSimpleName (); private static final double MIN_OPENGL_VERSION = 3.0; // Erstelle eine Mitgliedsvariable für ModelRenderable // private ModelRenderable dinoRenderable; // Erstelle eine Mitgliedsvariable für 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) // Suchen Sie das Fragment mit dem Fragment-Manager // getSupportFragmentManager (). findFragmentById (R.id.main_fragment); if (Build.VERSION.SDK_INT> = VERSION_CODES.N) {// ModelRenderable erstellen // ModelRenderable.builder () .setSource (this, R.raw.dinosaur) .build () .thenAccept (renderable -> dinoRenderable = renderable ) .exceptionally (// Wenn ein Fehler auftritt ... // throwable -> {//... dann Folgendes in Logcat ausgeben // Log.e (TAG, "Renderbar kann nicht geladen werden"); null zurückgeben;} ); } // Auf onTap-Ereignisse warten // arCoreFragment.setOnTapArPlaneListener ((HitResult hitResult, Ebene, MotionEvent motionEvent) -> {if (dinoRenderable == null) {return;} Anchor anchor = hitResult.createAnchor (); // Build a Knoten vom Typ AnchorNode // AnchorNode anchorNode = new AnchorNode (anchor); // Verbinde den AnchorNode mit der Szene // anchorNode.setParent (arCoreFragment.getArSceneView (). getScene ()); // Erstelle einen Knoten vom Typ TransformableNode // TransformableNode transformableNode = new TransformableNode (arCoreFragment.getTransformationSystem ()); // Verbinde den TransformableNode mit dem AnchorNode // transformableNode.setParent (anchorNode); // Hänge den Renderable // transformableNode.setRenderable (dinoRenderable); // Set the node / / transformableNode.select ();}); } public static boolean checkDevice (letzte Aktivität) {// Wenn auf dem Gerät Android Marshmallow oder früher ausgeführt wird ... // if (Build.VERSION.SDK_INT <VERSION_CODES.N) {//... dann drucken Sie Folgendes aus Logcat // Log.e (TAG, "Sceneform erfordert Android N oder höher"); activity.finish (); falsch zurückgeben; } String openGlVersionString = ((ActivityManager) activity.getSystemService (Context.ACTIVITY_SERVICE)) .getDeviceConfigurationInfo () // Überprüfen Sie die Version von OpenGL ES // .getGlEsVersion (); // Wenn auf dem Gerät weniger als OpenGL ES 3.0 ausgeführt wird ... // if (Double.parseDouble (openGlVersionString) <MIN_OPENGL_VERSION) {//... dann Folgendes in Logcat ausgeben // Log.e (TAG, " Benötigt OpenGL ES 3.0 oder höher "); activity.finish (); falsch zurückgeben; } return true; }}

Sie können das fertige Projekt von GitHub herunterladen.

Testen Sie Ihre Google ARCore Augmented Reality-App

Jetzt können Sie Ihre Anwendung auf einem physischen, unterstützten Android-Gerät testen. Wenn Sie kein Gerät besitzen, das ARCore unterstützt, können Sie Ihre AR-App im Android-Emulator testen (mit einer zusätzlichen Konfiguration, die im nächsten Abschnitt behandelt wird).

So testen Sie Ihr Projekt auf einem physisch Android-Gerät:

• Installieren Sie Ihre Anwendung auf dem Zielgerät.
• Gewähren Sie der Anwendung nach Aufforderung Zugriff auf die Kamera Ihres Geräts.
• Wenn Sie aufgefordert werden, die ARCore-App zu installieren oder zu aktualisieren, tippen Sie auf "Weiter" und schließen Sie den Dialog ab, um sicherzustellen, dass Sie die neueste und beste Version von ARCore ausführen.
• Sie sollten jetzt eine Kameraansicht mit einer Animation einer Hand sehen, die ein Gerät hält. Richten Sie die Kamera auf eine ebene Fläche und bewegen Sie Ihr Gerät in kreisenden Bewegungen, wie die Animation zeigt. Nach einigen Augenblicken sollte eine Reihe von Punkten angezeigt werden, die darauf hinweisen, dass eine Ebene erkannt wurde.

• Wenn Sie mit der Position dieser Punkte zufrieden sind, tippen Sie darauf - Ihr 3D-Modell sollte nun auf der ausgewählten Ebene angezeigt werden!

• Versuchen Sie, sich physisch im Modell zu bewegen. Abhängig von Ihrer Umgebung sind Sie möglicherweise in der Lage, die volle 360-Grad-Umdrehung zu machen. Sie sollten auch überprüfen, ob das Objekt einen Schatten wirft, der mit den Lichtquellen der realen Welt übereinstimmt.

Testen von ARCore auf einem virtuellen Android-Gerät

Zum Testen Ihrer ARCore-Apps auf einem virtuellen Android-Gerät (AVD) benötigen Sie Android Emulator, Version 27.2.9 oder höher. Sie müssen auch im Google Play Store auf Ihrer AVD angemeldet sein und OpenGL ES 3.0 oder höher aktiviert haben.

So überprüfen Sie, ob OpenGL ES 3.0 oder höher derzeit auf Ihrer AVD aktiviert ist:

• Starten Sie Ihre AVD wie gewohnt.
• Öffnen Sie ein neues Terminalfenster (Mac) oder eine Eingabeaufforderung (Windows).
• Wechseln Sie das Verzeichnis ("cd"), sodass die Terminal- / Eingabeaufforderung auf den Speicherort des "adb" -Programms Ihres Android SDK zeigt. Mein Befehl sieht beispielsweise folgendermaßen aus:

CD / Benutzer / Jessicathornsby / Bibliothek / Android / SDK / Plattform-Tools

• Drücken Sie die Eingabetaste auf Ihrer Tastatur.
• Kopieren Sie den nächsten Befehl in das Terminal, und drücken Sie die Eingabetaste:

./adb logcat | grep eglMakeCurrent

Wenn das Terminal "ver 3 0" oder höher zurückgibt, ist OpenGL ES korrekt konfiguriert. Wenn auf dem Terminal oder der Eingabeaufforderung eine frühere Version als 3.0 angezeigt wird, müssen Sie OpenGL ES 3.0 aktivieren:

• Wechseln Sie zurück zu Ihrem AVD.
• Suchen Sie den Streifen mit den Schaltflächen für die erweiterte Steuerung, der sich neben dem Android-Emulator befindet, und wählen Sie dann "Einstellungen> Erweitert".
• Navigieren Sie zu "OpenGL ES API-Ebene> Renderer-Maximum (bis OpenGL ES 3.1)".
• Starten Sie den Emulator neu.

Kopieren Sie im Fenster Terminal / Eingabeaufforderung den folgenden Befehl, fügen Sie ihn ein und drücken Sie die Eingabetaste.

./adb logcat | grep eglMakeCurrent

Sie sollten jetzt ein Ergebnis von „ver 3 0“ oder höher erhalten, was bedeutet, dass OpenGL ES korrekt konfiguriert ist.

Stellen Sie schließlich sicher, dass auf Ihrer AVD die neueste Version von ARCore ausgeführt wird:

• Besuchen Sie die GitHub-Seite von ARCore und laden Sie die neueste Version von ARCore für den Emulator herunter. Zum Zeitpunkt des Schreibens war die neueste Version beispielsweise "ARCore_1.7.0.x86_for_emulator.apk".
• Ziehen Sie die APK per Drag & Drop auf Ihre laufende AVD.

Um Ihr Projekt auf einer AVD zu testen, installieren Sie Ihre Anwendung und gewähren Sie ihr Zugriff auf die "Kamera" der AVD, wenn Sie dazu aufgefordert werden.

Sie sollten nun eine Kameraansicht eines simulierten Raums sehen. Um Ihre Anwendung zu testen, bewegen Sie sich in diesem virtuellen Raum, suchen Sie eine simulierte ebene Fläche und klicken Sie, um ein Modell auf dieser Fläche zu platzieren.

Sie können die virtuelle Kamera durch den virtuellen Raum bewegen, indem Sie die Tasten „Option“ (macOS) oder „Alt“ (Linux oder Windows) gedrückt halten und anschließend eine der folgenden Tastenkombinationen verwenden:

• Bewegen Sie sich nach links oder rechts. Drücken Sie A oder D.
• Bewegen Sie sich nach unten oder oben. Drücken Sie Q oder E.
• Vorwärts oder rückwärts gehen. Drücken Sie W oder S.

Sie können sich auch in der virtuellen Szene „bewegen“, indem Sie „Wahl“ oder „Alt“ drücken und dann Ihre Maus verwenden. Dies kann sich zunächst etwas klobig anfühlen, aber mit etwas Übung sollten Sie in der Lage sein, den virtuellen Raum erfolgreich zu erkunden. Wenn Sie eine simulierte Ebene gefunden haben, klicken Sie auf die weißen Punkte, um Ihr 3D-Modell auf dieser Oberfläche zu platzieren.

Einpacken

In diesem Artikel haben wir eine einfache Augmented Reality-App mit ARCore und dem Sceneform-Plugin erstellt.

Wenn Sie Google ARCore in Ihren eigenen Projekten verwenden möchten, teilen Sie Ihre Kreationen in den Kommentaren unten mit!