Zbuduj aplikację na Androida w rozszerzonej rzeczywistości dzięki Google ARCore

Wideo: Create an Augmented Reality App in Android | App Development Tutorial | Android Studio

Zawartość

Importowanie modeli 3D za pomocą wtyczki Sceneform
Instalowanie wtyczki Sceneform
Sceneform UX i Java 8: Aktualizacja zależności projektu
Żądanie uprawnień za pomocą ArFragment
Wymagane AR czy opcjonalne?
1. Wymagane AR
2. AR Opcjonalne
Dodaj ArFragment do swojego układu
Pobieranie modeli 3D za pomocą Google Poly
Importowanie modeli 3D do Android Studio
Wyświetl swój model 3D
1. Utwórz zmienną składową ArFragment
2. Zbuduj ModelRenderable
3. Odpowiedz na dane wprowadzone przez użytkownika
4. Zakotwicz swój model
5. Dodaj obsługę przesuwania, skalowania i obracania
Ukończona MainActivity
Testowanie aplikacji rozszerzonej rzeczywistości Google ARCore
Testowanie ARCore na urządzeniu wirtualnym z Androidem
Podsumowując

Importowanie modeli 3D za pomocą wtyczki Sceneform

Zwykle praca z modelami 3D wymaga specjalistycznej wiedzy, ale dzięki wydaniu wtyczki Sceneform Google umożliwiło renderowanie modeli 3D za pomocą Java - i bez konieczność nauki OpenGL.

Wtyczka Sceneform zapewnia interfejs API wysokiego poziomu, którego można używać do tworzenia renderowalnych tabel ze standardowych widżetów, kształtów lub materiałów dla Androida lub z zasobów 3D, takich jak pliki .OBJ lub .FBX.

W naszym projekcie użyjemy wtyczki Sceneform do zaimportowania pliku .OBJ do Android Studio. Za każdym razem, gdy importujesz plik za pomocą Sceneform, ta wtyczka automatycznie:

Konwertuj plik zasobów na plik .sfb. Jest to zoptymalizowany w czasie wykonywania format Sceneform Binary (.sfb), który został dodany do twojego APK, a następnie załadowany w czasie wykonywania. Użyjemy tego pliku .sfb, aby utworzyć Renderowalny, który składa się z siatek, materiałów i tekstur i może być umieszczony w dowolnym miejscu w rozszerzonej scenie.
Wygeneruj plik .sfa. Jest to plik opisu zasobu, który jest plikiem tekstowym zawierającym czytelny dla człowieka opis pliku .sfb. W zależności od modelu możesz zmienić jego wygląd, edytując tekst w pliku .sfa.

Pamiętaj tylko, że w momencie pisania wtyczka Sceneform była wciąż w fazie beta, więc możesz napotkać błędy, błędy lub inne dziwne zachowania podczas korzystania z tej wtyczki.

Instalowanie wtyczki Sceneform

Wtyczka Sceneform wymaga systemu Android Studio 3.1 lub nowszego. Jeśli nie masz pewności, której wersji Androida Studio używasz, wybierz „Android Studio> O Android Studio” z paska narzędzi. Kolejne okienko zawiera podstawowe informacje o instalacji Android Studio, w tym numer wersji.

Aby zainstalować wtyczkę Sceneform:

Jeśli korzystasz z komputera Mac, wybierz „Android Studio> Preferencje…” z paska narzędzi Android Studio, a następnie wybierz „Wtyczki” z menu po lewej stronie. Jeśli korzystasz z komputera z systemem Windows, wybierz „Plik> Ustawienia> Wtyczki> Przeglądaj repozytoria”.
Wyszukaj „Sceneform”. Gdy pojawi się „Google Sceneform Tools”, wybierz „Zainstaluj”.
Po wyświetleniu monitu uruchom ponownie Android Studio, a wtyczka będzie gotowa do użycia.

Sceneform UX i Java 8: Aktualizacja zależności projektu

Zacznijmy od dodania zależności, których będziemy używać w tym projekcie. Otwórz plik build.gradle na poziomie modułu i dodaj bibliotekę Sceneform UX, która zawiera ArFragment, którego będziemy używać w naszym układzie:

zależności {implementacja fileTree (reż: libs, include:) implementacja androidx.appcompat: appcompat: 1.0.2 implementacja androidx.constraintlayout: constraintlayout: 1.1.3 test Implementation junit: junit: 4.12 androidTestImplementation androidx.test.ext: junit: 1.1.0 androidTestImplementation androidx.test.espresso: espresso-core: 3.1.1 // Sceneform UX zapewnia zasoby UX, w tym ArFragment // implementacja „com.google.ar.sceneform.ux: sceneform-ux: 1.7.0„ implementacja ”com. android.support:appcompat-v7:28.0.0 "}

Sceneform wykorzystuje konstrukcje językowe z Java 8, więc musimy również zaktualizować Kompatybilność źródłową i docelową kompatybilności z Javą 8:

compileOptions {sourceCompatibility JavaVersion.VERSION_1_8 targetCompatibility JavaVersion.VERSION_1_8}

Na koniec musimy zastosować wtyczkę Sceneform:

zastosuj wtyczkę: com.google.ar.sceneform.plugin

Twój skompilowany plik build.gradle powinien wyglądać mniej więcej tak:

zastosuj wtyczkę: com.android.application android {compileSdkVersion 28 defaultConfig {applicationId "com.jessicathornsby.arcoredemo" minSdkVersion 23 targetSdkVersion 28 versionCode 1 versionName "1.0" testInstrumentationRunner "androidx.test.runner.AndroidJUnitionsVisionner {} JavaVersion.VERSION_1_8} buildTypes {release {minifyEnabled false proguardFiles getDefaultProguardFile (proguard-android-optimize.txt), proguard-rules.pro}}} zależności {implement fileTree (reż: libs, obejmują:) implementacja androidx.appcompat: appcompat: 1.0 .2 wdrożenie 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: implementacja 3.1.1 "com.google. ar.sceneform.ux: sceneform-ux: 1.7.0 „Implementacja” com.android.support:appcompat-v7:28.0.0 "} Zastosuj wtyczkę: com.google.ar .sceneform.plugin

Żądanie uprawnień za pomocą ArFragment

Nasza aplikacja użyje kamery urządzenia do analizy otoczenia i położenia modeli 3D w świecie rzeczywistym. Zanim nasza aplikacja będzie mogła uzyskać dostęp do kamery, wymaga pozwolenia kamery, więc otwórz manifest projektu i dodaj:

Android 6.0 dał użytkownikom możliwość przyznawania, odmawiania i odwoływania uprawnień na podstawie uprawnień po zezwoleniu. Chociaż poprawiło to komfort użytkowania, programiści Androida muszą teraz ręcznie żądać uprawnień w czasie wykonywania i obsługiwać odpowiedzi użytkownika. Dobrą wiadomością jest to, że podczas pracy Google ARCore zaimplementowany jest proces żądania zgody na kamerę i obsługi odpowiedzi użytkownika automatycznie.

Komponent ArFragment automatycznie sprawdza, czy twoja aplikacja ma uprawnienia do kamery, a następnie w razie potrzeby żąda jej przed utworzeniem sesji AR. Ponieważ będziemy używać ArFragment w naszej aplikacji, nie musimy pisać żadnego kodu, aby poprosić o pozwolenie na aparat.

Wymagane AR czy opcjonalne?

Istnieją dwa typy aplikacji korzystających z funkcji AR:

1. Wymagane AR

Jeśli Twoja aplikacja korzysta z Google ARCore, aby zapewnić wygodę użytkowania, musisz upewnić się, że jest ona pobierana tylko na urządzenia obsługujące ARCore. Jeśli oznaczysz swoją aplikację jako „Wymagane AR”, pojawi się ona tylko w sklepie Google Play, jeśli urządzenie obsługuje ARCore.

Od naszej aplikacji robi wymagają ARCore, otwórz Manifest i dodaj:

Istnieje również szansa, że Twoja aplikacja może zostać pobrana na urządzenie, które teoretycznie obsługuje ARCore, ale tak naprawdę nie ma zainstalowanego ARCore. Po oznaczeniu naszej aplikacji jako „Wymagane AR” Google Play automatycznie pobierze i zainstaluje ARCore wraz z twoją aplikacją, jeśli nie jest jeszcze obecna na urządzeniu docelowym.

Pamiętaj tylko, że nawet jeśli Twoja aplikacja jest na Androida: wymagana = „prawda”, będziesz nadal musisz sprawdzić, czy ARCore jest obecny w czasie wykonywania, ponieważ istnieje prawdopodobieństwo, że użytkownik odinstalował ARCore od czasu pobrania Twojej aplikacji lub że jego wersja ARCore jest nieaktualna.

Dobra wiadomość jest taka, że korzystamy z ArFragment, który automatycznie sprawdza, czy ARCore jest zainstalowany i aktualny przed utworzeniem każdy Sesja AR - więc po raz kolejny nie musimy tego wdrażać ręcznie.

2. AR Opcjonalne

Jeśli Twoja aplikacja zawiera funkcje AR, które są przyjemne w użyciu, ale nie są niezbędne do zapewnienia jej podstawowej funkcjonalności, możesz oznaczyć tę aplikację jako „Opcjonalnie AR”. Twoja aplikacja może następnie sprawdzić, czy Google ARCore jest obecny w czasie wykonywania, i wyłączyć jego Funkcje AR na urządzeniach, które nie obsługują ARCore.

Jeśli utworzysz aplikację „AR Opcjonalnie”, ARCore zrobi to nie być automatycznie instalowany wraz z aplikacją, nawet jeśli urządzenie ma cały sprzęt i oprogramowanie wymagane do obsługi ARCore. Twoja aplikacja „AR Opcjonalna” będzie musiała sprawdzić, czy ARCore jest obecny i aktualny, oraz pobrać najnowszą wersję w razie potrzeby.

Jeśli ARCore nie ma decydującego znaczenia dla Twojej aplikacji, możesz dodać do Manifestu:

Podczas gdy mam otwarty Manifest, dodaję również Androida: configChanges i android: screenOrientation, aby zapewnić płynną zmianę orientacji MainActivity.

Po dodaniu tego wszystkiego do manifestu, ukończony plik powinien wyglądać mniej więcej tak:

Dodaj ArFragment do swojego układu

Będę korzystać z ArFragment ARCore, ponieważ automatycznie obsługuje on szereg kluczowych zadań ARCore na początku każdej sesji AR. Co najważniejsze, ArFragment sprawdza, czy na urządzeniu jest zainstalowana kompatybilna wersja ARCore i czy aplikacja ma obecnie uprawnienia do kamery.

Gdy ArFragment sprawdzi, czy urządzenie może obsługiwać funkcje AR aplikacji, tworzy sesję ArSceneView ARCore, a wrażenia AR aplikacji są gotowe!

Możesz dodać fragment ArFragment do pliku układu, podobnie jak zwykły fragment Androida, więc otwórz plik activity_main.xml i dodaj składnik „com.google.ar.sceneform.ux.ArFragment”.

Pobieranie modeli 3D za pomocą Google Poly

Istnieje kilka różnych sposobów tworzenia Renderable, ale w tym artykule użyjemy pliku zasobów 3D.

Sceneform obsługuje zasoby 3D w formatach .OBJ, .glTF i .FBX, z animacjami lub bez. Istnieje wiele miejsc, w których można uzyskać modele 3D w jednym z tych obsługiwanych formatów, ale w tym samouczku będę korzystać z pliku .OBJ, pobranego z repozytorium Poly Google.

Przejdź na stronę Poly i pobierz zasób, którego chcesz użyć, w formacie .OBJ (używam tego modelu T-Rex).

Rozpakuj folder, który powinien zawierać plik źródłowy zasobu Twojego modelu (.OBJ, .FBX lub .glTF). W zależności od modelu ten folder może również zawierać pewne zależności modelu, takie jak pliki w formacie .mtl, .bin, .png lub .jpeg.

Importowanie modeli 3D do Android Studio

Gdy masz już zasób, musisz go zaimportować do Android Studio przy użyciu wtyczki Sceneform. Jest to wieloetapowy proces, który wymaga:

Utwórz folder „sampledata”. Sampledata to nowy typ folderu dla przykładowych danych projektowych, które nie zostaną uwzględnione w twoim pliku APK, ale będą dostępne w edytorze Android Studio.
Przeciągnij i upuść oryginalny plik zasobów .OBJ do folderu „sampledata”.
Wykonaj import i konwersję Sceneform do pliku .OBJ, który wygeneruje pliki .sfa i .sfb.

Chociaż może się to wydawać prostsze, nie przeciągnij i upuść plik .OBJ bezpośrednio do katalogu „res” projektu, ponieważ spowoduje to niepotrzebne dołączenie modelu do pliku APK.

Projekty w Android Studio domyślnie nie zawierają folderu „sampledata”, dlatego musisz go utworzyć ręcznie:

Kliknij z wciśniętym klawiszem Control folder „aplikacji” swojego projektu.
Wybierz „Nowy> Przykładowy katalog danych” i utwórz folder o nazwie „sampledata”.
Przejdź do wcześniej pobranych plików modelu 3D. Znajdź źródłowy plik zasobu (.OBJ, .FBX lub .glTF), a następnie przeciągnij go i upuść w katalogu „sampledata”.
Sprawdź, czy Twój model ma jakieś zależności (na przykład pliki w formacie .mtl, .bin, .png lub .jpeg). Jeśli znajdziesz któryś z tych plików, przeciągnij i upuść je w folderze „sampledata”.
W Android Studio, kliknij z wciśniętym klawiszem Control plik źródłowy modelu 3D (.OBJ, .FBX lub .glTF), a następnie wybierz „Importuj scenę”.

Kolejne okno wyświetla informacje o plikach, które Sceneform ma wygenerować, w tym o tym, gdzie wynikowy plik .sfa będzie przechowywany w twoim projekcie; Będę używać katalogu „raw”.
Gdy podoba Ci się wprowadzona informacja, kliknij „Zakończ”.

Ten import wprowadza kilka zmian do twojego projektu. Jeśli otworzysz plik build.gradle, zobaczysz, że wtyczka Sceneform została dodana jako zależność projektu:

zależności {classpath com.android.tools.build:gradle:3.5.0-alpha06 classpath com.google.ar.sceneform: plugin: 1.7.0 // UWAGA: Nie umieszczaj tutaj zależności aplikacji; należą one // do poszczególnych plików build.gradle modułu}}

Otwórz plik build.gradle na poziomie modułu, a znajdziesz nowy wpis sceneform.asset () dla importowanego modelu 3D:

zastosuj wtyczkę: com.google.ar.sceneform.plugin // „Ścieżka zasobu źródłowego” określona podczas importu // sceneform.asset (sampledata / dinosaur.obj, // „Ścieżka materiału” określona podczas importu // Domyślna , // „Ścieżka wyjściowa .sfa” określona podczas importu // sampledata / dinosaur.sfa, // „Ścieżka wyjściowa .sfa” określona podczas importu // src / main / asset / dinosaur)

Jeśli spojrzysz na foldery „sampledata” i „raw”, zobaczysz, że zawierają one odpowiednio nowe pliki .sfa i .sfb.

Możesz wyświetlić podgląd pliku .sfa w nowej aplikacji Sceneform Viewer w Android Studio:

Wybierz „Widok> Narzędzia Windows> Przeglądarka” z paska menu Android Studio.
W menu po lewej stronie wybierz plik .sfa. Twój model 3D powinien teraz pojawić się w oknie przeglądarki.

Wyświetl swój model 3D

Naszym kolejnym zadaniem jest stworzenie sesji AR, która rozumie otoczenie i pozwala użytkownikowi umieszczać modele 3D w rozszerzonej scenie.

Wymaga to od nas wykonania następujących czynności:

1. Utwórz zmienną składową ArFragment

ArFragment wykonuje wiele ciężkich zadań związanych z tworzeniem sesji AR, więc będziemy odwoływać się do tego fragmentu w naszej klasie MainActivity.

W poniższym fragmencie tworzę zmienną składową dla ArFragment, a następnie inicjuję ją w metodzie onCreate ():

prywatny ArFragment arCoreFragment; @Override chronione void onCreate (pakiet saveInstanceState) {super.onCreate (saveInstanceState); ... ... ...} setContentView (R.layout.activity_main); arCoreFragment = (ArFragment) // Znajdź fragment, używając menedżera fragmentów // getSupportFragmentManager (). findFragmentById (R.id.main_fragment);

2. Zbuduj ModelRenderable

Teraz musimy przekształcić nasz plik .sfb w ModelRenderable, który ostatecznie wyrenderuje nasz obiekt 3D.

Tutaj tworzę ModelRenderable z pliku res / raw / dinosaur .sfb mojego projektu:

prywatny ModelRenderable dinoRenderable; ... ... ... ModelRenderable.builder () .setSource (this, R.raw.dinosaur) .build () .thenAccept (renderable -> dinoRenderable = renderable). Wyjątkowo (rzucalny -> {Log.e ( TAG, „Nie można załadować renderowalnego”); zwraca null;}); }

3. Odpowiedz na dane wprowadzone przez użytkownika

ArFragment ma wbudowaną obsługę gestów stukania, przeciągania, szczypania i skręcania.

W naszej aplikacji użytkownik doda model 3D do płaszczyzny ARCore, stukając w tę płaszczyznę.

Aby zapewnić tę funkcjonalność, musimy zarejestrować połączenie zwrotne, które będzie wywoływane za każdym razem, gdy samolot zostanie dotknięty:

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

4. Zakotwicz swój model

W tym kroku odzyskamy ArSceneView i dołączymy do AnchorNode, który będzie pełnił rolę węzła nadrzędnego sceny.

ArSceneView jest odpowiedzialny za wykonanie kilku ważnych zadań ARCore, w tym renderowanie obrazów z kamery urządzenia oraz wyświetlanie animacji Sceneform UX, która pokazuje, jak użytkownik powinien trzymać i przesuwać urządzenie, aby rozpocząć korzystanie z AR. ArSceneView podświetli również wszystkie wykryte płaszczyzny, gotowe do umieszczenia modeli 3D w scenie.

Do komponentu ARSceneView dołączona jest Scena, która jest strukturą danych rodzic-dziecko zawierającą wszystkie węzły, które należy wyrenderować.

Zaczniemy od utworzenia węzła typu AnchorNode, który będzie działał jako węzeł nadrzędny naszego ArSceneView.

Wszystkie węzły zakotwiczenia pozostają w tej samej pozycji w świecie rzeczywistym, więc tworząc węzeł zakotwiczenia upewniamy się, że nasze modele 3D pozostaną nieruchome na miejscu w rozszerzonej scenie.

Utwórzmy nasz węzeł kotwiczny:

AnchorNode anchorNode = new AnchorNode (anchor);

Następnie możemy pobrać ArSceneView za pomocą getArSceneView () i dołączyć go do AnchorNode:

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

5. Dodaj obsługę przesuwania, skalowania i obracania

Następnie utworzę węzeł typu TransformableNode. TransformableNode jest odpowiedzialny za przesuwanie, skalowanie i obracanie węzłów na podstawie gestów użytkownika.

Po utworzeniu TransformableNode możesz dołączyć Renderable, co da modelowi możliwość skalowania i przesuwania, w oparciu o interakcję użytkownika. Na koniec musisz połączyć TransformableNode z AnchorNode, w relacji potomek-rodzic, która zapewnia TransformableNode i Renderowalne pozostają ustalone na miejscu w rozszerzonej scenie.

TransformableNode transformableNode = new TransformableNode (arCoreFragment.getTransformationSystem ()); // Połącz transformableNode z anchorNode // transformableNode.setParent (anchorNode); transformableNode.setRenderable (dinoRenderable); // Wybierz węzeł // transformableNode.select (); }); }

Ukończona MainActivity

Po wykonaniu wszystkich powyższych czynności Twoja MainActivity powinna wyglądać mniej więcej tak:

import android.app.Activity; import android.app.ActivityManager; import androidx.appcompat.app.AppCompatActivity; import android.content.Context; import android.net.Uri; import android.os.Build; import android.os.Build.VERSION_CODES; import android.os.Bundle; import android.util.Log; import android.view.MotionEvent; import androidx.annotation.RequiresApi; import com.google.ar.core.Anchor; import com.google.ar.core.HitResult; import com.google.ar.core.Plane; import com.google.ar.sceneform.AnchorNode; import com.google.ar.sceneform.rendering.ModelRenderable; import com.google.ar.sceneform.ux.ArFragment; import com.google.ar.sceneform.ux.TransformableNode; klasa publiczna MainActivity rozszerza AppCompatActivity {private static final Łańcuch TAG = MainActivity.class.getSimpleName (); prywatny statyczny końcowy podwójny MIN_OPENGL_VERSION = 3.0; // Utwórz zmienną składową dla ModelRenderable // private ModelRenderable dinoRenderable; // Utwórz zmienną składową dla ArFragment // private ArFragment arCoreFragment; @RequiresApi (api = VERSION_CODES.N) @Override chronione void onCreate (pakiet saveInstanceState) {super.onCreate (saveInstanceState); if (! checkDevice ((this))) {return; } setContentView (R.layout.activity_main); arCoreFragment = (ArFragment) // Znajdź fragment, używając menedżera fragmentów // getSupportFragmentManager (). findFragmentById (R.id.main_fragment); if (Build.VERSION.SDK_INT> = VERSION_CODES.N) {// Zbuduj ModelRenderable // ModelRenderable.builder () .setSource (this, R.raw.dinosaur) .build () .thenAccept (renderable -> dinoRenderable = renderable ). wyjątkowo (// Jeśli wystąpi błąd ... // rzucalny -> {//..., a następnie wydrukuj poniższy komunikat do Logcat // Log.e (TAG, „Nie można załadować renderowalnego”); return null;} ); } // Nasłuchuj zdarzeń onTap // arCoreFragment.setOnTapArPlaneListener ((HitResult hitResult, płaszczyzna, MotionEvent motionEvent) -> {if (dinoRenderable == null) {return;} Anchor anchor = hitResult.createAnchor (); // Zbuduj węzeł typu AnchorNode // AnchorNode anchorNode = nowy AnchorNode (anchor); // Połącz AnchorNode ze sceną // anchorNode.setParent (arCoreFragment.getArSceneView (). getScene ()); // Zbuduj węzeł typu TransformableNode // TransformableNode transformableNode = new TransformableNode (arCoreFragment.getTransformationSystem ()); // Połącz TransformableNode z AnchorNode // transformableNode.setParent (anchorNode); // Dołącz Renderable // transformableNode.setRenderable (dinoRenderable); // Ustaw węzeł / / transformableNode.select ();}); } public static boolean checkDevice (ostatnia aktywność działania) {// Jeśli na urządzeniu działa system Android Marshmallow lub wcześniejszy ... // if (Build.VERSION.SDK_INT <VERSION_CODES.N) {//... następnie wydrukuj następujące Logcat // Log.e (TAG, „Sceneform wymaga Androida N lub nowszego”); activity.finish (); zwracać fałsz; } Ciąg openGlVersionString = ((ActivityManager) activity.getSystemService (Context.ACTIVITY_SERVICE)) .getDeviceConfigurationInfo () // Sprawdź wersję OpenGL ES // .getGlEsVersion (); // Jeśli na urządzeniu działa coś mniejszego niż OpenGL ES 3.0 ... // if (Double.parseDouble (openGlVersionString) <MIN_OPENGL_VERSION) {//... następnie wydrukuj następujące dane do Logcat // Log.e (TAG, „ Wymaga OpenGL ES 3.0 lub nowszego ”); activity.finish (); zwracać fałsz; } return true; }}

Możesz pobrać ukończony projekt z GitHub.

Testowanie aplikacji rozszerzonej rzeczywistości Google ARCore

Teraz możesz przetestować aplikację na fizycznym, obsługiwanym urządzeniu z Androidem. Jeśli nie masz urządzenia obsługującego ARCore, możesz przetestować swoją aplikację AR w emulatorze Androida (z odrobiną dodatkowej konfiguracji, którą omówimy w następnej sekcji).

Aby przetestować swój projekt na fizyczny Urządzenie z Androidem:

Zainstaluj aplikację na urządzeniu docelowym.
Po wyświetleniu monitu udziel aplikacji dostęp do kamery urządzenia.
Jeśli pojawi się monit o zainstalowanie lub aktualizację aplikacji ARCore, dotknij „Kontynuuj”, a następnie zakończ dialog, aby upewnić się, że korzystasz z najnowszej i najlepszej wersji ARCore.
Powinieneś teraz zobaczyć widok z kamery wraz z animacją ręki trzymającej urządzenie. Skieruj kamerę na płaską powierzchnię i poruszaj urządzeniem ruchem okrężnym, jak pokazano na animacji. Po kilku chwilach powinna pojawić się seria kropek wskazujących, że wykryto płaszczyznę.

Gdy jesteś zadowolony z położenia tych kropek, dotknij ich - Twój model 3D powinien teraz pojawić się na wybranej płaszczyźnie!

Spróbuj fizycznie poruszać się po modelu; w zależności od otoczenia możesz zrobić pełne 360 stopni wokół niego. Powinieneś również sprawdzić, czy obiekt rzuca cień zgodny z rzeczywistymi źródłami światła.

Testowanie ARCore na urządzeniu wirtualnym z Androidem

Aby przetestować aplikacje ARCore na urządzeniu wirtualnym z systemem Android (AVD), potrzebujesz emulatora Androida w wersji 27.2.9 lub nowszej. Musisz także zalogować się do sklepu Google Play na swoim AVD i mieć włączony OpenGL ES 3.0 lub wyższy.

Aby sprawdzić, czy w AVD jest obecnie włączony OpenGL ES 3.0 lub nowszy:

Uruchom AVD, jak zwykle.
Otwórz nowe okno terminala (Mac) lub wiersz polecenia (Windows).
Zmień katalog („cd”), aby Terminal / Wiersz polecenia wskazywał lokalizację programu „adb” pakietu SDK systemu Android, na przykład moje polecenie wygląda następująco:

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

Naciśnij klawisz „Enter” na klawiaturze.
Skopiuj / wklej następne polecenie do terminala, a następnie naciśnij klawisz „Enter”:

./adb logcat | grep eglMakeCurrent

Jeśli Terminal zwróci „ver 3 0” lub wyższy, to OpenGL ES jest poprawnie skonfigurowany. Jeśli terminal lub wiersz polecenia wyświetla coś wcześniejszego niż 3.0, musisz włączyć OpenGL ES 3.0:

Wróć do AVD.
Znajdź pasek przycisków „Rozszerzona kontrola” unoszących się obok emulatora Androida, a następnie wybierz „Ustawienia> Zaawansowane”.
Przejdź do „Poziom API OpenGL ES> Maksimum renderowania (do OpenGL ES 3.1).”
Uruchom ponownie emulator.

W oknie Terminal / Command Prompt skopiuj / wklej następujące polecenie, a następnie naciśnij klawisz „Enter”

./adb logcat | grep eglMakeCurrent

Powinieneś teraz otrzymać wynik „ver 3 0” lub wyższy, co oznacza, że OpenGL ES jest poprawnie skonfigurowany.

Na koniec upewnij się, że na AVD jest uruchomiona najnowsza wersja ARCore:

Udaj się na stronę GitHub ARCore i pobierz najnowszą wersję ARCore dla emulatora. Na przykład w momencie pisania najnowszej wersji „ARCore_1.7.0.x86_for_emulator.apk”
Przeciągnij i upuść APK na działającym systemie AVD.

Aby przetestować swój projekt na AVD, zainstaluj aplikację i udziel jej dostęp do „kamery” AVD, gdy pojawi się odpowiedni monit.

Powinieneś teraz zobaczyć widok symulowanego pokoju z kamery. Aby przetestować aplikację, poruszaj się po tej wirtualnej przestrzeni, znajdź symulowaną płaską powierzchnię i kliknij, aby umieścić model na tej powierzchni.

Możesz przenosić wirtualną kamerę po wirtualnym pokoju, naciskając i przytrzymując klawisze „Opcja” (macOS) lub „Alt” (Linux lub Windows), a następnie używając dowolnego z następujących skrótów klawiaturowych:

Przesuń w lewo lub w prawo. Naciśnij A lub D.
Przejdź w dół lub w górę. Naciśnij Q lub E.
Przejdź do przodu lub do tyłu. Naciśnij W lub S.

Możesz także „poruszać się” po wirtualnej scenie, naciskając „Opcja” lub „Alt”, a następnie używając myszy. Na początku może się to wydawać trochę niezręczne, ale dzięki praktyce powinieneś być w stanie z powodzeniem eksplorować wirtualną przestrzeń. Po znalezieniu symulowanej płaszczyzny kliknij białe kropki, aby umieścić model 3D na tej powierzchni.

Podsumowując

W tym artykule stworzyliśmy prostą aplikację rzeczywistości rozszerzonej, używając ARCore i wtyczki Sceneform.

Jeśli zdecydujesz się używać Google ARCore we własnych projektach, pamiętaj o udostępnieniu swoich dzieł w komentarzach poniżej!