Създайте приложение за Android с разширена реалност с Google ARCore

Съдържание

Импортиране на 3D модели с плъгин Sceneform
Инсталиране на приставка за Sceneform
Sceneform UX и Java 8: Актуализиране на зависимостите на вашия проект
Изискване на разрешения с ArFragment
AR задължително или незадължително?
1. Изисква се AR
2. AR незадължително
Добавете ArFragment към оформлението си
Изтегляне на 3D модели с помощта на Poly на Google
Импортиране на 3D модели в Android Studio
Покажете вашия 3D модел
1. Създайте променлива на член ArFragment
2. Изградете ModelRenderable
3. Отговорете на въвеждането на потребителя
4. Прикрепете модела си
5. Добавете поддръжка за движение, мащабиране и завъртане
Завършената MainActivity
Тестване на приложението за разширена реалност на Google ARCore
Тестване на ARCore на виртуално устройство с Android
Обобщавайки

Импортиране на 3D модели с плъгин Sceneform

Обикновено работата с 3D модели изисква специализирани познания, но с пускането на приставката Sceneform Google направи възможно рендерирането на 3D модели с помощта на Java - и без трябва да научите OpenGL.

Плъгинът на Sceneform осигурява API на високо ниво, който можете да използвате за създаване на Renderdables от стандартни Android джаджи, форми или материали или от 3D активи, като .OBJ или .FBX файлове.

В нашия проект ще използваме приставката Sceneform за импортиране на .OBJ файл в Android Studio. Всеки път, когато импортирате файл с помощта на Sceneform, тази приставка автоматично:

Преобразувайте файла с активи във .sfb файл. Това е оптимизиран за изпълнение сценарий двоичен формат (.sfb), който се добавя към вашия APK и след това се зарежда по време на изпълнение. Ще използваме този .sfb файл, за да създадем Renderable, който се състои от мрежи, материали и текстури и може да бъде поставен навсякъде в разширената сцена.
Генериране на .sfa файл. Това е файл с описание на активите, който представлява текстов файл, съдържащ четено от човека описание на .sfb файла. В зависимост от модела, можете да промените външния му вид, като редактирате текста във файла .sfa.

Само имайте предвид, че по време на писането приставката Sceneform все още беше в бета версия, така че можете да срещнете грешки, грешки или друго странно поведение, когато използвате този плъгин.

Инсталиране на приставка за Sceneform

Приставката Sceneform изисква Android Studio 3.1 или по-нова версия. Ако не сте сигурни коя версия на Android Studio използвате, изберете „Android Studio> Всичко за Android Studio“ от лентата с инструменти. Следващото изскачащо меню съдържа някои основни данни за вашата инсталация на Android Studio, включително номера на неговата версия.

За да инсталирате приставката Sceneform:

Ако сте на Mac, изберете „Android Studio> Предпочитания…“ от лентата с инструменти на Android Studio, след което изберете „Plugins“ от лявото меню. Ако сте на компютър с Windows, изберете "Файл> Настройки> Приставки> Преглед на хранилища."
Потърсете „Sceneform.“ Когато се появи „Инструменти на Google Sceneform“, изберете „Инсталиране“.
Рестартирайте Android Studio, когато бъдете подканени, и вашата приставка ще бъде готова за използване.

Sceneform UX и Java 8: Актуализиране на зависимостите на вашия проект

Нека започнем с добавяне на зависимостите, които ще използваме в този проект. Отворете файла на build.gradle на ниво модул и добавете библиотеката Sceneform UX, която съдържа ArFragment, който ще използваме в нашето оформление:

зависимости {изпълнение fileTree (реж .: libs, включва:) внедряване androidx.appcompat: appcompat: 1.0.2 внедряване 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 предоставя UX ресурси, включително ArFragment // изпълнение „com.google.ar.sceneform.ux: sceneform-ux: 1.7.0„ изпълнение “com. android.support:appcompat-v7:28.0.0 "}

Sceneform използва езикови конструкции от Java 8, така че също така ще трябва да актуализираме съвместимостта на източници и целевата съвместимост на нашия проект до Java 8:

compileOptions {sourceCompatibility JavaVersion.VERSION_1_8 targetCompatibility JavaVersion.VERSION_1_8}

Накрая трябва да приложим приставката Sceneform:

приложете приставка: com.google.ar.sceneform.plugin

Вашият завършен файл build.gradle трябва да изглежда така:

прилага плъгин: com.android.application андроид {compileSdkVersion 28 defaultConfig {applicationId "com.jessicathornsby.arcoredemo" minSdkVersion 23 targetSdkVersion 28 VersionCode 1 VersionName "1.0" testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"} compileOptions {sourceCompatibility JavaVersion.VERSION_1_8 targetCompatibility JavaVersion.VERSION_1_8} buildTypes {release {minifyEnabled false proguardFiles getDefaultProguardFile (proguard-android-optimize.txt), proguard-rules.pro}}} зависимости {изпълнение fileTree (dir: libs, включва:) внедряване androidx.appcompat: appcompat .2 внедряване 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 изпълнение „com.google. ar.sceneform.ux: sceneform-ux: 1.7.0 "внедряване" com.android.support:appcompat-v7:28.0.0 "} приложете приставка: com.google.ar .sceneform.plugin

Изискване на разрешения с ArFragment

Нашето приложение ще използва камерата на устройството, за да анализира обкръжението му и да позиционира 3D модели в реалния свят. Преди нашето приложение да получи достъп до камерата, то изисква разрешение на камерата, така че отворете манифеста на вашия проект и добавете следното:

Android 6.0 даде възможност на потребителите да предоставят, отказват и отнемат разрешения на базата на разрешение по разрешение. Въпреки че това подобри потребителското изживяване, разработчиците на Android сега трябва ръчно да поискат разрешения по време на изпълнение и да обработят отговора на потребителя. Добрата новина е, че при работа с Google ARCore се прилага процесът на искане на разрешение на камерата и обработка на отговора на потребителя. автоматично.

Компонентът ArFragment автоматично проверява дали приложението ви има разрешение за камера и след това го изисква, ако е необходимо, преди да създадете AR сесия. Тъй като ще използваме ArFragment в нашето приложение, не е необходимо да пишем код, за да искаме разрешение на камерата.

AR задължително или незадължително?

Има два типа приложения, които използват AR функционалност:

1. Изисква се AR

Ако вашето приложение разчита на Google ARCore, за да осигури добро потребителско изживяване, тогава трябва да се уверите, че се изтегля само някога на устройства, които поддържат ARCore. Ако маркирате приложението си като „AR Required“, то то ще се показва само в магазина на Google Play, ако устройството поддържа ARCore.

От нашето приложение прави изисква ARCore, отворете Manifest и добавете следното:

Има шанс приложението ви да бъде изтеглено на устройство, което теоретично поддържа ARCore, но всъщност няма инсталиран ARCore. След като маркираме нашето приложение като „Необходимо за AR“, Google Play автоматично ще изтегли и инсталира ARCore заедно с приложението ви, ако то вече не е налице на целевото устройство.

Трябва само да знаете, че дори и приложението ви да е android: задължително = „вярно“, вие ще бъдете все още трябва да проверите дали ARCore присъства по време на изпълнение, тъй като има вероятност потребителят да деинсталира ARCore след изтеглянето на приложението ви или дали тяхната версия на ARCore е остаряла.

Добрата новина е, че използваме ArFragment, който автоматично проверява дали ARCore е инсталиран и актуален преди създаването всеки AR сесия - така че още веднъж, това не е необходимо да прилагаме ръчно.

2. AR незадължително

Ако приложението ви включва AR функции, които са приятни за разполагане, но не са от съществено значение за осигуряването на неговата основна функционалност, тогава можете да маркирате това приложение като „AR незадължително“. След това приложението ви може да провери дали Google ARCore присъства по време на изпълнение и да деактивира AR функции на устройства, които не поддържат ARCore.

Ако създадете приложение „AR Незадължително“, ARCore ще го направи не да се инсталира автоматично заедно с приложението ви, дори ако устройството разполага с целия хардуер и софтуер, необходими за поддръжка на ARCore. След това вашето приложение „AR незадължително“ ще трябва да провери дали ARCore присъства и е актуален, и да изтегли последната версия, както и когато е необходимо.

Ако ARCore не е от решаващо значение за приложението ви, тогава можете да добавите следното към Manifest:

Докато манифестът е отворен, добавям и android: configChanges и android: screenOrientation, за да гарантирам, че MainActivity дръжките на ориентацията се променят изящно.

След като добавите всичко това към вашия Manifest, завършеният файл трябва да изглежда така:

Добавете ArFragment към оформлението си

Ще използвам ArFragment на ARCore, тъй като той автоматично обработва редица ключови задачи на ARCore в началото на всяка AR сесия. Най-важното е, че ArFragment проверява дали на устройството е инсталирана съвместима версия на ARCore и че приложението в момента има разрешение за камера.

След като ArFragment потвърди, че устройството може да поддържа AR функциите на приложението ви, създава сесия ArSceneView ARCore и AR опитът на приложението ви е готов!

Можете да добавите фрагмента на ArFragment към файл с оформление, точно като обикновен Android фрагмент, така че отворете файла Activity_main.xml и добавете компонент „com.google.ar.sceneform.ux.ArFragment“.

Изтегляне на 3D модели с помощта на Poly на Google

Има няколко различни начина, по които можете да създавате Renderables, но в тази статия ще използваме файл с триизмерни активи.

Sceneform поддържа 3D активи във формати .OBJ, .glTF и .FBX, със или без анимации. Има много места, където можете да закупите 3D модели в един от тези поддържани формати, но в този урок ще използвам .OBJ файл, изтеглен от хранилището на Google в поли.

Преминете към уебсайта на Poly и изтеглете актива, който искате да използвате, във формат .OBJ (използвам този модел T-Rex).

Разархивирайте папката, която трябва да съдържа файла на изходния актив на вашия модел (.OBJ, .FBX или .glTF). В зависимост от модела, тази папка може също да съдържа някои зависимости от модела, като например файлове във форматите .mtl, .bin, .png или .jpeg.

Импортиране на 3D модели в Android Studio

След като разполагате с вашия актив, трябва да го импортирате в Android Studio с помощта на приставката Sceneform. Това е многоетапен процес, който изисква:

Създайте папка „sampledata“. Sampledata е нов тип папка за примерни данни за времето за проектиране, които няма да бъдат включени във вашия APK, но ще бъдат достъпни в редактора на Android Studio.
Плъзнете и пуснете оригиналния .OBJ файл с активи в папката „sampledata“.
Извършете импортирането и преобразуването на Sceneform във .OBJ файла, който ще генерира .sfa и .sfb файловете.

Въпреки че може да изглежда по-прям, не плъзнете и пуснете .OBJ файла директно в директорията „res“ на вашия проект, тъй като това ще доведе до излишно включване на модела в APK.

Проектите за Android Studio не съдържат папка „sampledata“ по подразбиране, така че ще трябва да създадете ръчно:

Щракнете върху папката „app“ на вашия проект с контролен бутон
Изберете „New> Sample Data Directory“ и създайте папка, наречена „sampledata“.
Отворете файловете на 3D модела, които сте изтеглили по-рано. Намерете файла на изходния актив (.OBJ, .FBX или .glTF) и след това го плъзнете и пуснете в директорията „sampledata“.
Проверете дали вашият модел има някакви зависимости (като файлове във формати .mtl, .bin, .png или .jpeg). Ако намерите някой от тези файлове, след това ги плъзнете и пуснете в папката "sampledata".
В Android Studio, Control, щракнете върху вашия изходен файл с 3D модел (.OBJ, .FBX или .glTF) и след това изберете „Import Sceneform Asset.“

Следващият прозорец показва някаква информация за файловете, които ще генерира Sceneform, включително къде ще се съхранява полученият .sfa файл във вашия проект; Ще използвам „суровата“ директория.
Когато сте доволни от въведената информация, щракнете върху „Край“.

Това импортиране прави няколко промени във вашия проект. Ако отворите файла build.gradle, ще видите, че приставката Sceneform е добавена като зависимост на проекта:

зависимости {classpath com.android.tools.build:gradle:3.5.0-alpha06 classpath com.google.ar.sceneform: плъгин: 1.7.0 // ЗАБЕЛЕЖКА: Не поставяйте зависимостите на приложението си тук; те принадлежат // в отделния модул build.gradle файлове}}

Отворете файла на build.gradle на ниво модул и ще намерите нов запис на formform.asset () за импортирания 3D модел:

приложете плъгин: com.google.ar.sceneform.plugin // „Пътят към източника на активи“, който сте посочили по време на импортиране // sceneform.asset (sampledata / dinosaur.obj, // „Материален път“, който сте посочили по време на импортиране // По подразбиране , // ".sfa изходен път", който сте посочили по време на импортиране // sampledata / dinosaur.sfa, // ".sfb изходния път", който сте посочили по време на импортиране // src / main / активи / динозавър)

Ако погледнете вашите „sampledata“ и „raw“ папки, ще видите, че те съдържат съответно нови .sfa и .sfb файлове.

Можете да прегледате .sfa файла в новия Sceneform Viewer на Android Studio:

Изберете „View“ Tools Windows> Viewer от лентата на менюто на Android Studio.
В менюто отляво изберете вашия .sfa файл. Вашият 3D модел сега трябва да се появи в прозореца на Viewer.

Покажете вашия 3D модел

Следващата ни задача е да създадем AR сесия, която разбира нейната среда и позволява на потребителя да постави 3D модели в разширена сцена.

Това изисква да направим следното:

1. Създайте променлива на член ArFragment

ArFragment изпълнява голяма част от тежкото повдигане, участващо в създаването на AR сесия, така че ще отнесем този фрагмент в нашия клас MainActivity.

В следния фрагмент създавам променлива на член за ArFragment и след това го инициализирам в метода onCreate ():

частен ArFragment arCoreFragment; @Override защитена празнота onCreate (Bundle saveInstanceState) {super.onCreate (saveInstanceState); ... ... ...} setContentView (R.layout.activity_main); arCoreFragment = (ArFragment) // Намерете фрагмента, използвайки мениджъра на фрагменти // getSupportFragmentManager (). findFragmentById (R.id.main_fragment);

2. Изградете ModelRenderable

Сега трябва да трансформираме .sfb файла си в ModelRenderable, който в крайна сметка ще направи нашия 3D обект.

Ето, създавам ModelRenderable от res / raw / dinosaur .sfb файла на моя проект:

частен ModelRenderable dinoRenderable; ... ... ... ModelRenderable.builder () .setSource (това, R.raw.dinosaur) .build () .thenAccept (renderable -> dinoRenderable = renderable) .execeptionly (може да се прехвърля -> {Log.e ( TAG, "Невъзможно зареждане на преносими"); return null;}); }

3. Отговорете на въвеждането на потребителя

ArFragment има вградена поддръжка за жестове за докосване, плъзгане, прищипване и завъртане.

В нашето приложение, потребителят ще добави триизмерен модел към ARCore самолет, като даде този самолет.

За да доставим тази функционалност, трябва да регистрираме обратен сигнал, който ще бъде извикан всеки път, когато се почука самолет:

arCoreFragment.setOnTapArPlaneListener ((HitResult hitResult, Самолетна равнина, MotionEvent motionEvent) -> {if (dinoRenderable == null) {return;}

4. Прикрепете модела си

В тази стъпка ще извлечем ArSceneView и ще го прикачим към AnchorNode, който ще служи като родителски възел на Scene.

ArSceneView е отговорен за изпълнението на няколко важни задачи на ARCore, включително изобразяване на изображенията на камерата на устройството и показване на Sceneform UX анимация, която демонстрира как потребителят трябва да държи и премества устройството си, за да стартира AR опит. ArSceneView също ще подчертае всички равнини, които засича, готови за потребителя да постави своите 3D модели в сцената.

Компонентът ARSceneView има прикрепена сцена към него, която е структура на данни родител-дете, съдържаща всички възли, които трябва да бъдат рендирани.

Ще започнем със създаването на възел от тип AnchorNode, който ще действа като родителски възел на нашия ArSceneView.

Всички анкерни възли остават в една и съща позиция в реалния свят, така че създавайки котва за въвеждане, ние гарантираме, че нашите 3D модели ще останат фиксирани на място в разширената сцена.

Нека създадем нашия котва:

AnchorNode anchorNode = нов AnchorNode (котва);

След това можем да извлечем ArSceneView, използвайки getArSceneView (), и да го прикачим към AnchorNode:

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

5. Добавете поддръжка за движение, мащабиране и завъртане

След това ще създам възел от тип TransformableNode. TransformableNode е отговорен за преместване, мащабиране и въртене на възли въз основа на жестовете на потребителя.

След като създадете TransformableNode, можете да го прикачите Renderable, което ще даде на модела възможност да мащабира и да се движи въз основа на взаимодействието с потребителя. И накрая, трябва да свържете TransformableNode към AnchorNode, в взаимоотношение дете-родител, което гарантира TransformableNode и Предаваемите остават фиксирани на мястото си в разширената сцена.

TransformableNode transformableNode = нов TransformableNode (arCoreFragment.getTransformationSystem ()); // Свържете transformableNode с anchorNode // transformableNode.setParent (anchorNode); transformableNode.setRenderable (dinoRenderable); // Изберете възела // transformableNode.select (); }); }

Завършената MainActivity

След като изпълните всичко по-горе, вашата MainActivity трябва да изглежда така:

импортиране на android.app.Activity; импортиране на android.app.ActivityManager; импортиране на androidx.appcompat.app.AppCompatActivity; импортиране на android.content.Context; import android.net.Uri; импортиране на android.os.Build; импортиране на android.os.Build.VERSION_CODES; импортиране на android.os.Bundle; import android.util.Log; импортиране на android.view.MotionEvent; импортиране androidx.annotation.RequiresApi; импортиране на com.google.ar.core.Anchor; импортиране на com.google.ar.core.HitResult; импортиране на com.google.ar.core.Plane; импортиране на com.google.ar.sceneform.AnchorNode; импортиране на com.google.ar.sceneform.rendering.ModelRenderable; импортиране на com.google.ar.sceneform.ux.ArFragment; импортиране на com.google.ar.sceneform.ux.TransformableNode; обществен клас MainActivity разширява AppCompatActivity {частен статичен окончателен String TAG = MainActivity.class.getSimpleName (); частен статичен краен двойник MIN_OPENGL_VERSION = 3.0; // Създайте променлива на член за ModelRenderable // private ModelRenderable dinoRenderable; // Създаване на променлива на член за ArFragment // частен ArFragment arCoreFragment; @RequiresApi (api = VERSION_CODES.N) @ Защитена празнота празнота onCreate (Bundle saveInstanceState) {super.onCreate (saveInstanceState); if (! checkDevice ((this))) {return; } setContentView (R.layout.activity_main); arCoreFragment = (ArFragment) // Намерете фрагмента, използвайки мениджъра на фрагменти // getSupportFragmentManager (). findFragmentById (R.id.main_fragment); if (Build.VERSION.SDK_INT> = VERSION_CODES.N) {// Създаване на ModelRenderable // ModelRenderable.builder () .setSource (this, R.raw.dinosaur) .build () .thenAccept (renderable -> dinoRenderable = renderable ). по изключение (// Ако възникне грешка ... // хвърляща се -> {//..., след това отпечатайте следното в Logcat // Log.e (TAG, "Не може да се зареди предаване"); return null;} ); } // Слушайте за събитията в onTap // arCoreFragment.setOnTapArPlaneListener ((HitResult hitResult, Самолетна равнина, MotionEvent motionEvent) -> {if (dinoRenderable == null) {return;} Anchor anchor = hitResult.createAnchor (); възел от тип AnchorNode // AnchorNode anchorNode = нов AnchorNode (котва); // Свържете AnchorNode със сцената // anchorNode.setParent (arCoreFragment.getArSceneView (). getScene ()); // Изграждане на възел от тип TransformableNode // TransformableNode transformableNode = нов TransformableNode (arCoreFragment.getTransformationSystem ()); // Свързване на TransformableNode с AnchorNode // transformableNode.setParent (anchorNode); // Прикачване на предаващия // transformableNode.setRenderable (dinoRenderable); / transformableNode.select ();}); } обществена статична булева проверка на устройството (крайна активност на дейността) {// Ако устройството работи с Android Marshmallow или по-рано ... // if (Build.VERSION.SDK_INT <VERSION_CODES.N) {//... тогава отпечатайте следното на Logcat // Log.e (TAG, "Sceneform изисква Android N или по-висока версия"); activity.finish (); върнете невярно; } String openGlVersionString = ((ActivityManager) activity.getSystemService (Context.ACTIVITY_SERVICE)) .getDeviceConfigurationInfo () // Проверете версията на OpenGL ES // .getGlEsVersion (); // Ако устройството работи с нещо по-малко от OpenGL ES 3.0 ... // if (Double.parseDouble (openGlVersionString) <MIN_OPENGL_VERSION) {//...подпечатайте следното в Logcat // Log.e (TAG, " Изисква OpenGL ES 3.0 или по-нова версия “); activity.finish (); върнете невярно; } върнете вярно; }}

Можете да изтеглите завършения проект от GitHub.

Тестване на приложението за разширена реалност на Google ARCore

Вече сте готови да тествате приложението си на физическо, поддържано Android устройство. Ако не притежавате устройство, което поддържа ARCore, тогава е възможно да тествате приложението си AR в Android Emulator (с малко допълнителна конфигурация, която ще покрием в следващия раздел).

За да тествате проекта си на a физически Устройство с Android:

Инсталирайте приложението си на целевото устройство.
Когато бъдете подканени, предоставете на приложението достъп до камерата на вашето устройство.
Ако бъдете подканени да инсталирате или актуализирате приложението ARCore, докоснете „Продължи“ и след това завършете диалога, за да сте сигурни, че използвате най-новата и най-добра версия на ARCore.
Сега трябва да видите изглед на камера, допълнен с анимация на ръка, която държи устройство. Насочете камерата към равна повърхност и движете устройството си с кръгово движение, както е показано от анимацията. След няколко мига трябва да се появи поредица от точки, показващи, че е открит самолет.

След като сте доволни от позицията на тези точки, дайте им крак - вашият 3D модел вече трябва да се появи в избраната от вас плоскост!

Опитайте физически да се движите около модела; в зависимост от вашето обкръжение, може да успеете да направите пълните 360 градуса около него. Трябва също така да проверите дали обектът хвърля сянка, която е в съответствие с светлинните източници в реалния свят.

Тестване на ARCore на виртуално устройство с Android

За да тествате приложенията си ARCore във виртуално устройство за Android (AVD), ще ви трябва Android Emulator версия 27.2.9 или по-нова. Трябва също да сте влезли в магазина на Google Play на вашия AVD и да имате OpenGL ES 3.0 или по-нова версия.

За да проверите дали OpenGL ES 3.0 или по-нова версия е активирана в момента на вашия AVD:

Стартирайте AVD, както обикновено.
Отворете нов прозорец на терминала (Mac) или команден ред (Windows).
Променете директорията („cd“), така че терминалът / командният ред сочи местоположението на програмата „adb“ на вашата SDK за Android, например моята команда изглежда така:

Cd / Потребители / jessicathornsby / Библиотека / Android / sdk / платформа-инструменти

Натиснете клавиша „Enter“ на клавиатурата си.
Копирайте / поставете следващата команда в терминала и натиснете клавиша „Enter“:

./adb logcat | grep eglMakeCurrent

Ако терминалът връща „ver 3 0“ или по-висока, тогава OpenGL ES е конфигуриран правилно. Ако терминалът или командният ред показва нещо по-рано от 3.0, тогава ще трябва да активирате OpenGL ES 3.0:

Превключете обратно към вашия AVD.
Намерете лентата от бутоните „Разширен контрол“, която плава редом с Android емулатора, след което изберете „Настройки> Разширени“.
Навигирайте до „OpenGL ES API API ниво> Renderer максимум (до OpenGL ES 3.1).“
Рестартирайте емулатора.

В прозореца Terminal / Command Prompt копирайте / поставете следната команда и след това натиснете клавиша „Enter“

./adb logcat | grep eglMakeCurrent

Сега трябва да получите резултат от „ver 3 0“ или по-висока, което означава, че OpenGL ES е конфигуриран правилно.

И накрая, уверете се, че вашият AVD работи с най-новата версия на ARCore:

Отидете на страницата на GitHub на ARCore и изтеглете най-новата версия на ARCore за емулатора. Например, по време на писането най-новото издание беше „ARCore_1.7.0.x86_for_emulator.apk“
Плъзнете и пуснете APK файла към вашия работещ AVD.

За да тествате проекта си на AVD, инсталирайте приложението си и му предоставете достъп до „камерата“ на AVD, когато бъдете подканени.

Сега трябва да видите камерен изглед на симулирана стая. За да тествате приложението си, преместете се във това виртуално пространство, намерете симулирана плоска повърхност и щракнете, за да поставите модел на тази повърхност.

Можете да местите виртуалната камера около виртуалната стая, като натиснете и задържите клавишите „Option“ (macOS) или „Alt“ (Linux или Windows) и след това използвате някой от следните клавишни комбинации:

Движете се наляво или надясно. Натиснете A или D.
Движете се надолу или нагоре. Натиснете Q или E.
Движете се напред или назад. Натиснете W или S.

Можете също така да се "движите" из виртуалната сцена, като натиснете "Option" или "Alt" и след това използвате мишката. Това може да се почувства малко тромаво в началото, но с практиката трябва да можете да изследвате успешно виртуалното пространство. След като намерите симулирана равнина, щракнете върху белите точки, за да поставите вашия 3D модел върху тази повърхност.

Обобщавайки

В тази статия създадохме просто приложение за разширена реалност, използвайки ARCore и приставката Sceneform.

Ако решите да използвате Google ARCore в собствените си проекти, тогава не забравяйте да споделите вашите творения в коментарите по-долу!