Bangun aplikasi Android realiti bertambah dengan Google ARCore

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

Kandungan

Mengimport model 3D, dengan plugin Sceneform
Memasang plugin Sceneform
Sceneform UX dan Java 8: Mengemaskini kebergantungan projek anda
Meminta izin dengan ArFragment
AR Dikehendaki atau Pilihan?
1. AR Diperlukan
2. AR Pilihan
Tambah Arfragment ke susun atur anda
Memuat turun model 3D, menggunakan Poli Google
Mengimport model 3D ke Android Studio
Paparkan model 3D anda
1. Buat pembolehubah ahli Arfragment
2. Membina ModelRenderable
3. Merespon input pengguna
4. Anchor model anda
5. Tambah sokongan untuk bergerak, penskalaan dan berputar
MainActivity yang telah selesai
Uji apl realiti tambahan ARCore Google anda
Menguji ARCore pada Peranti Maya Android
Mengakhiri

Mengimport model 3D, dengan plugin Sceneform

Biasanya, bekerja dengan model 3D memerlukan pengetahuan pakar, tetapi dengan pembebasan plugin Sceneform Google telah memungkinkan untuk menjadikan model 3D menggunakan Java - dan tanpa perlu belajar OpenGL.

Plugin Sceneform menyediakan API peringkat tinggi yang boleh anda gunakan untuk membuat Renderdables dari widget, bentuk atau bahan Android standard, atau dari aset 3D, seperti fail .OBJ atau .FBX.

Dalam projek kami, kami akan menggunakan plugin Sceneform untuk mengimport fail .OBJ ke Android Studio. Setiap kali anda mengimport fail menggunakan Sceneform, plugin ini secara automatik:

Tukar fail aset ke dalam fail .sfb. Ini adalah format Biner Sceneform yang dioptimumkan untuk runtime (.sfb) yang ditambahkan pada APK anda dan kemudian dimuatkan pada masa runtime. Kami akan menggunakan fail .ffb ini untuk membuat Renderable, yang terdiri daripada jerat, bahan dan tekstur, dan boleh diletakkan di mana-mana dalam adegan tambahan.
Buat fail .sfa. Ini adalah fail penerangan aset, yang merupakan fail teks yang mengandungi huraian yang boleh dibaca manusia bagi fail .fb. Bergantung pada model, anda mungkin dapat mengubah penampilannya dengan mengedit teks di dalam fail .sfa.

Hanya sedar bahawa pada masa penulisan, plugin Sceneform masih dalam beta, jadi anda mungkin menghadapi pepijat, kesilapan, atau perilaku pelik lain apabila menggunakan plugin ini.

Memasang plugin Sceneform

Plugin Sceneform memerlukan Android Studio 3.1 atau lebih tinggi. Jika anda tidak pasti versi Android Studio yang anda gunakan, pilih "Android Studio> Mengenai Android Studio" dari bar alat. Popup berikutnya mengandungi beberapa maklumat asas tentang pemasangan Android Studio anda, termasuk nombor versinya.

Untuk memasang plugin Sceneform:

Jika anda berada di Mac, pilih "Android Studio> Keutamaan ..." dari bar alat Android Studio, kemudian pilih "Plugin" dari menu sebelah kiri. Jika anda berada di PC Windows, kemudian pilih "Fail> Tetapan> Plugin> Semak imbas repositori."
Cari "Sceneform." Apabila "Tools Sceneform Google" muncul, pilih "Pasang."
Restart Android Studio apabila digesa, dan plugin anda akan sedia untuk digunakan.

Sceneform UX dan Java 8: Mengemaskini kebergantungan projek anda

Mari mulakan dengan menambahkan dependensi yang akan kami gunakan sepanjang projek ini. Buka file build.gradle tahap modul anda, dan tambah pustaka Sceneform UX, yang mengandungi ArFragment yang akan kami gunakan dalam susun atur kami:

dependencies {implementation fileTree (dir: libs, include:) implementation androidx.appcompat: appcompat: 1.0.2 implementation 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 menyediakan sumber UX, termasuk ArFragment // implementation "com.google.ar.sceneform.ux: sceneform-ux: 1.7.0" implementation "com. android.support:appcompat-v7:28.0.0 "}

Sceneform menggunakan bahasa membina dari Java 8, jadi kami juga perlu mengemas kini Kesesuaian Sumber projek dan Kesesuaian Sasaran untuk Java 8:

compileOptions {sourceCompatibility JavaVersion.VERSION_1_8 targetCompatibility JavaVersion.VERSION_1_8}

Akhirnya, kita perlu memohon plugin Sceneform:

gunakan plugin: com.google.ar.sceneform.plugin

Fail build.gradle anda yang lengkap harus kelihatan seperti ini:

memohon plugin: com.android.application android {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}}} dependencies {implementation fileTree (dir: libs, include:) implementation androidx.appcompat: appcompat: 1.0 .2 pelaksanaan 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 implementation "com.google. ar.sceneform.ux: adegan-ux: 1.7.0 "pelaksanaan" com.android.support:appcompat-v7:28.0.0 "} memohon plugin: com.google.ar .sceneform.plugin

Meminta izin dengan ArFragment

Aplikasi kami akan menggunakan kamera peranti untuk menganalisis persekitaran dan kedudukan model 3D di dunia nyata. Sebelum permohonan kami boleh mengakses kamera, ia memerlukan kebenaran kamera, jadi buka Manifest projek anda dan tambah yang berikut:

Android 6.0 memberikan pengguna keupayaan untuk memberi, menafikan dan membatalkan kebenaran berdasarkan kebenaran oleh kebenaran. Walaupun ini meningkatkan pengalaman pengguna, pemaju Android kini perlu meminta kebenaran secara manual semasa runtime, dan mengendalikan tindak balas pengguna. Berita baiknya ialah apabila bekerja Google ARCore, proses meminta izin kamera dan menangani respons pengguna dilaksanakan secara automatik.

Komponen ArFragment secara automatik memeriksa sama ada aplikasi anda mempunyai kebenaran kamera dan kemudian memintanya, jika diperlukan, sebelum membuat sesi AR. Oleh kerana kami akan menggunakan ArFragment dalam aplikasi kami, kami tidak perlu menulis sebarang kod untuk meminta kebenaran kamera.

AR Dikehendaki atau Pilihan?

Terdapat dua jenis aplikasi yang menggunakan fungsi AR:

1. AR Diperlukan

Sekiranya aplikasi anda bergantung kepada Google ARCore untuk memberikan pengalaman pengguna yang baik, maka anda perlu memastikan ia hanya dimuat turun ke peranti yang menyokong ARCore. Jika anda menandakan aplikasi anda sebagai "AR Diperlukan" maka ia hanya akan muncul di kedai Google Play, jika peranti itu menyokong ARCore.

Sejak permohonan kami tidak memerlukan ARCore, buka Manifest dan tambah yang berikut:

Terdapat juga kemungkinan permohonan anda boleh dimuat turun ke peranti yang menyokong ARCore secara teori, tetapi sebenarnya tidak mempunyai ARCore dipasang. Sebaik sahaja kami menandakan aplikasi kami sebagai "AR Diperlukan" Google Play secara automatik akan memuat turun dan memasang ARCore bersama aplikasi anda, jika ia tidak ada pada peranti sasaran.

Hanya sedar bahawa walaupun aplikasi anda adalah android: diperlukan = "benar" anda akan masih ada perlu semak bahawa ARCore hadir semasa runtime, kerana terdapat peluang pengguna mungkin telah menyahpasang ARCore sejak memuat turun aplikasi anda, atau versi ARCore mereka sudah lapuk.

Berita baiknya ialah kami menggunakan ArFragment, yang secara automatik memeriksa ARCore dipasang dan terkini sebelum membuat setiap Sesi AR - jadi sekali lagi, ini adalah sesuatu yang kita tidak perlu melaksanakan secara manual.

2. AR Pilihan

Sekiranya aplikasi anda termasuk ciri AR yang bagus tetapi tidak penting untuk menyampaikan fungsi terasnya, maka anda boleh menandakan permohonan ini sebagai "AR Pilihan." Apl anda kemudian dapat memeriksa sama ada Google ARCore hadir pada masa runtuh, dan melumpuhkan Ciri AR pada peranti yang tidak menyokong ARCore.

Jika anda membuat aplikasi "AR Pilihan", maka ARCore akan tidak secara automatik dipasang bersama aplikasi anda, walaupun peranti mempunyai semua perkakasan dan perisian yang diperlukan untuk menyokong ARCore. Aplikasi "Opsyen AR" anda kemudian perlu menyemak sama ada ARCore hadir dan terkini, dan memuat turun versi terkini apabila diperlukan.

Jika ARCore tidak penting untuk apl anda, maka anda boleh menambah perkara berikut kepada Manifes anda:

Walaupun saya mempunyai Terbuka yang Manifes, saya juga menambah android: configChanges dan android: screenOrientation, untuk memastikan MainActivity menangani orientasi berubah dengan anggun.

Selepas menambah semua ini kepada Manifest anda, fail yang lengkap harus kelihatan seperti ini:

Tambah Arfragment ke susun atur anda

Saya akan menggunakan ArFragment ARCore, kerana ia secara automatik mengendalikan beberapa tugas ARCore utama pada permulaan setiap sesi AR. Terutama, ArFragment menyemak bahawa versi ARCore yang serasi dipasang pada peranti itu, dan aplikasi itu pada masa ini mempunyai kebenaran kamera.

Setelah ArFragment telah mengesahkan bahawa peranti itu boleh menyokong ciri AR aplikasi anda, ia membuat sesi ARCoreView ARCore, dan pengalaman AR aplikasi anda sudah bersedia untuk pergi!

Anda boleh menambah fragmen ArFragment ke fail susun atur, seperti Fragment Android biasa, jadi buka fail activity_main.xml anda dan tambah komponen "com.google.ar.sceneform.ux.ArFragment".

Memuat turun model 3D, menggunakan Poli Google

Terdapat beberapa cara yang berbeza untuk membuat Renderables, tetapi dalam artikel ini kita akan menggunakan fail aset 3D.

Sceneform menyokong aset 3D dalam format .OBJ, .glTF, dan .FBX, dengan atau tanpa animasi. Terdapat banyak tempat di mana anda boleh memperoleh model 3D dalam salah satu format yang disokong ini, tetapi dalam tutorial ini saya akan menggunakan fail .OBJ, dimuat turun dari repositori Poly Google.

Pergi ke laman web Poly dan muat turun aset yang anda mahu gunakan, dalam format .OBJ (Saya menggunakan model T-Rex ini).

Unzip folder, yang seharusnya mengandungi fail aset sumber model anda (.OBJ, .FBX, atau .glTF). Bergantung kepada model, folder ini mungkin juga mengandungi beberapa ketergantungan model, seperti fail dalam format .mtl, .bin, .png, atau .jpeg.

Mengimport model 3D ke Android Studio

Sebaik sahaja anda mempunyai aset anda, anda perlu mengimportnya ke Android Studio menggunakan plugin Sceneform. Ini adalah proses pelbagai langkah yang memerlukan anda untuk:

Buat folder "sampledata". Sampledata adalah jenis folder baru untuk data sampel masa reka bentuk yang tidak akan dimasukkan dalam APK anda, tetapi akan tersedia dalam editor Android Studio.
Seret dan lepaskan fail aset asal .OBJ ke folder "sampledata" anda.
Lakukan import dan penukaran Sceneform pada fail .OBJ, yang akan menjana fail .sfa dan .sfb.

Walaupun ia mungkin kelihatan lebih mudah, jangan seret dan jatuhkan fail .OBJ terus ke direktori "res" projek anda, kerana ini akan menyebabkan model dimasukkan ke dalam APK anda tidak perlu.

Projek Android Studio tidak mengandungi folder "sampledata" secara lalai, jadi anda perlu membuatnya secara manual:

Kawalan-klik folder "aplikasi" projek anda.
Pilih "Baru> Direktori Data Sampel" dan buat folder bernama "sampledata."
Navigasi ke fail model 3D yang anda muat turun sebelum ini. Cari fail aset sumber (.OBJ, .FBX, atau .glTF) dan kemudian seret dan jatuhkan ke dalam direktori "sampledata".
Semak sama ada model anda mempunyai sebarang ketergantungan (seperti fail dalam format .mtl, .bin, .png, atau .jpeg). Jika anda mendapati mana-mana fail ini, maka seret dan lepaskannya ke folder "sampledata".
Di Android Studio, klik Control-click file sumber model 3D anda (.OBJ, .FBX, atau .glTF) dan kemudian pilih "Import Sceneform Asset."

Tetingkap berikutnya memaparkan beberapa maklumat tentang fail yang akan dihasilkan oleh Sceneform, termasuk di mana fail .sfa yang dihasilkan akan disimpan dalam projek anda; Saya akan menggunakan direktori "mentah".
Apabila anda berpuas hati dengan maklumat yang anda masukkan, klik "Selesai."

Import ini membuat sedikit perubahan pada projek anda. Jika anda membuka fail build.gradle anda, maka anda akan melihat bahawa plugin Sceneform telah ditambah sebagai kebergantungan projek:

dependencies {classpath com.android.tools.build:gradle:3.5.0-alpha06 classpath com.google.ar.sceneform: plugin: 1.7.0 // NOTA: Jangan letakkan ketergantungan aplikasi anda di sini; mereka tergolong dalam mod build.gradle individu mod}}

Buka fail build.gradle tahap modul anda, dan anda akan dapati adeganformform.asset () untuk model 3D anda yang diimport:

gunakan plugin: com.google.ar.sceneform.plugin // "Sumber Aset Sumber" yang anda tentukan semasa import // sceneform.asset (sampledata / dinosaur.obj, // The "Path Material" yang anda tentukan semasa import // Default , // Laluan "Output .sfa" yang anda nyatakan semasa import // sampledata / dinosaur.sfa, / / "Path Output" .sfb yang anda tetapkan semasa import / src / main / assets / dinosaur)

Jika anda melihat folder "sampledata" dan "mentah" anda, maka anda akan melihat bahawa ia mengandungi fail .sfa dan .sfb baru, masing-masing.

Anda boleh melihat fail .sfa, dalam Penampil Sceneform baru Android Studio:

Pilih "View> Tools Windows> Viewer" dari bar menu Android Studio.
Di menu sebelah kiri, pilih fail .sfa anda. Model 3D anda kini harus muncul di tetingkap Viewer.

Paparkan model 3D anda

Tugas seterusnya kami ialah membuat sesi AR yang memahami persekitarannya, dan membolehkan pengguna meletakkan model 3D dalam adegan bertambah.

Ini memerlukan kami untuk melakukan perkara-perkara berikut:

1. Buat pembolehubah ahli Arfragment

ArFragment melakukan banyak mengangkat berat yang terlibat dalam membuat sesi AR, jadi kami akan merujuk fragmen ini ke seluruh kelas MainActivity kami.

Dalam coretan berikut, saya membuat pembolehubah ahli untuk ArFragment dan kemudian memulakannya dalam kaedah onCreate ():

ArFragment arCoreFragment swasta; @Override dilindungi tidak sah onCreate (Bundle savedInstanceState) {super.onCreate (savedInstanceState); ... ... ...} setContentView (R.layout.activity_main); arCoreFragment = (ArFragment) // Cari fragmen itu, menggunakan pengurus fragmen // getSupportFragmentManager (). findFragmentById (R.id.main_fragment);

2. Membina ModelRenderable

Sekarang kita perlu mengubah fail .ff kita ke dalam ModelRenderable, yang akhirnya akan menjadikan objek 3D kita.

Di sini, saya mencipta ModelRenderable dari fail res / raw / dinosaur .sfb projek saya:

peribadi ModelRenderable dinoRenderable; ... ... ... ModelRenderable.builder () .setSource (this, R.raw.dinosaur) .build () .thenAccept (renderable -> dinoRenderable = renderable) .exceptionally (throwable -> {Log.e ( TAG, "Tidak dapat memuatkan boleh ditukar"); kembali null;}); }

3. Merespon input pengguna

ArFragment mempunyai sokongan terbina untuk ketukan, seret, jepitan, dan isyarat twist.

Dalam apl kami, pengguna akan menambah model 3D ke ARCore Plane, dengan memberikan pesawat itu satu paip.

Untuk menyampaikan fungsi ini, kita perlu mendaftarkan panggilan balik yang akan digunakan setiap kali satah ditoreh:

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

4. Anchor model anda

Dalam langkah ini, kami akan mengambil ArSceneView dan melampirkannya ke AnchorNode, yang akan berfungsi sebagai nod induk Scene.

ArSceneView bertanggungjawab untuk melaksanakan beberapa tugas penting ARCore, termasuk membuat gambar kamera peranti, dan memaparkan animasi Sceneform UX yang menunjukkan bagaimana pengguna harus memegang dan memindahkan peranti mereka untuk memulakan pengalaman AR. ArSceneView juga akan menyerlahkan mana-mana pesawat yang dideteksi, bersedia untuk pengguna meletakkan model 3D mereka di tempat kejadian.

Komponen ARSceneView mempunyai Pemandangan yang dilampirkan kepadanya, yang merupakan struktur data ibu bapa-anak yang mengandungi semua Node yang perlu diberikan.

Kami akan bermula dengan membuat nod jenis AnchorNode, yang akan bertindak sebagai nod induk ArSceneView kami.

Semua nod jangkar kekal di kedudukan dunia sebenar yang sama, jadi dengan mewujudkan nod jangkar kami memastikan bahawa model 3D kami akan tetap tetap di tempat dalam adegan bertambah.

Mari buat simpulan utama kami:

AnchorNode anchorNode = AnchorNode baru (anchor);

Kita kemudian boleh mengambil ArSceneView, menggunakan getArSceneView (), dan lampirkannya ke AnchorNode:

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

5. Tambah sokongan untuk bergerak, penskalaan dan berputar

Seterusnya, saya akan membuat nod jenis TransformableNode. TransformableNode bertanggungjawab untuk memindahkan, penskalaan dan berputar nod, berdasarkan gerak isyarat pengguna.

Sebaik sahaja anda telah mencipta TransformableNode, anda boleh melampirkannya Renderable, yang akan memberi model keupayaan untuk skala dan bergerak, berdasarkan interaksi pengguna. Akhir sekali, anda perlu menyambungkan TransformableNode ke AnchorNode, dalam hubungan ibu bapa yang memastikan TransformableNode dan Renderable kekal tetap di tempat dalam adegan bertambah.

TransformableNode transformableNode = TransformableNode baru (arCoreFragment.getTransformationSystem ()); // Sambungkan transformableNode ke anchorNode // transformableNode.setParent (anchorNode); transformableNode.setRenderable (dinoRenderable); // Pilih node // transformableNode.select (); }); }

MainActivity yang telah selesai

Selepas melaksanakan semua perkara di atas, MainActivity anda harus kelihatan seperti ini:

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; MainActivity kelas awam memanjangkan AppCompatActivity {private static String akhir TAG = MainActivity.class.getSimpleName (); akhir akhir statik peribadi MIN_OPENGL_VERSION = 3.0; // Buat pembolehubah anggota untuk ModelRenderable // private ModelRenderable dinoRenderable; // Buat pembolehubah ahli untuk ArFragment // arFragment ArFragment swasta; @RequiresApi (api = VERSION_CODES.N) @Override dilindungi tidak sah onCreate (Bundle savedInstanceState) {super.onCreate (savedInstanceState); jika (! cekDevice ((this))) {return; } setContentView (R.layout.activity_main); arCoreFragment = (ArFragment) // Cari fragmen, dengan menggunakan fragmen manager // getSupportFragmentManager (). findFragmentById (R.id.main_fragment); jika (Build.VERSION.SDK_INT> = VERSION_CODES.N) {// Bina ModelRenderable // ModelRenderable.builder () .setSource (ini, R.raw.dinosaur) .build () .thenAccept (renderable -> dinoRenderable = renderable ) .exceptionally (// Jika ralat berlaku ... // boleh dibuang -> {// ... maka cetaklah yang berikut ke Logcat // Log.e (TAG, "Tidak dapat memuatkan boleh dijadikan"); kembali null;} ); } // Mendengar peristiwa onTap // arCoreFragment.setOnTapArPlaneListener ((hitResult hitResult, pesawat terbang, MovementEvent motionEvent) -> {if (dinoRenderable == null) {return;} jangkar jangkar = hitResult.createAnchor (); // Build a nod jenis AnchorNode // AnchorNode anchorNode = AnchorNode baru (anchor); // Sambungkan AnchorNode ke Scene // anchorNode.setParent (arCoreFragment.getArSceneView (). getScene ()); // Membina nod jenis TransformableNode // TransformableNode transformableNode = TransformableNode baru (arCoreFragment.getTransformationSystem ()); // Sambungkan TransformableNode ke AnchorNode // transformableNode.setParent (anchorNode); // Lampirkan Renderable // transformableNode.setRenderable (dinoRenderable); // Tetapkan nod / / transformableNode.select ();}); } pemeriksaan boolean statik awamDevice (aktiviti Kegiatan akhir) {// Jika peranti sedang menjalankan Android Marshmallow atau sebelumnya ... // jika (Bina.VERSION.SDK_INT <VERSION_CODES.N) {// ... maka cetak berikut untuk Logcat // Log.e (TAG, "Sceneform memerlukan Android N atau lebih tinggi"); activity.finish (); kembali palsu; } String openGlVersionString = ((ActivityManager) activity.getSystemService (Context.ACTIVITY_SERVICE)) .getDeviceConfigurationInfo () // Semak versi OpenGL ES // .getGlEsVersion (); // Jika peranti menjalankan apa-apa yang kurang daripada OpenGL ES 3.0 ... // if (Double.parseDouble (openGlVersionString) <MIN_OPENGL_VERSION) {/ / sebelum ini mencetak yang berikut ke Logcat // Log.e (TAG, " Memerlukan OpenGL ES 3.0 atau lebih tinggi "); activity.finish (); kembali palsu; } kembali benar; }}

Anda boleh memuat turun projek yang telah siap dari GitHub.

Uji apl realiti tambahan ARCore Google anda

Anda kini bersedia untuk menguji aplikasi anda pada peranti Android fizikal, yang disokong. Sekiranya anda tidak memiliki peranti yang menyokong ARCore, maka adalah mungkin untuk menguji apl AR anda dalam Emulator Android (dengan sedikit konfigurasi tambahan, yang akan kita pelajari di bahagian seterusnya).

Untuk menguji projek anda pada a fizikal Peranti Android:

Pasang aplikasi anda pada peranti sasaran.
Apabila digesa, beri akses aplikasi ke kamera peranti anda.
Jika digesa untuk memasang atau mengemas kini aplikasi ARCore, ketik "Teruskan" dan kemudian selesaikan dialog untuk memastikan anda menjalankan versi terbaru ARCore dan paling hebat.
Anda kini perlu melihat paparan kamera, lengkap dengan animasi tangan memegang peranti. Arahkan kamera ke permukaan yang rata dan gerakkan peranti anda dalam gerakan bulat, seperti yang ditunjukkan oleh animasi. Selepas beberapa saat, satu siri titik sepatutnya muncul, menunjukkan bahawa satah telah dikesan.

Sebaik sahaja anda berpuas hati dengan kedudukan titik-titik ini, beri mereka ketuk - model 3D anda kini akan muncul pada pesawat pilihan anda!

Cuba fizikal bergerak di sekitar model; bergantung pada persekitaran anda, anda mungkin dapat melakukan 360 derajat penuh di sekelilingnya. Anda juga harus memeriksa bahawa objek itu menyusun bayangan yang selaras dengan sumber cahaya dunia sebenar.

Menguji ARCore pada Peranti Maya Android

Untuk menguji aplikasi ARCore anda dalam Peranti Maya Maya (AVD), anda memerlukan Android Emulator versi 27.2.9 atau lebih tinggi. Anda juga mesti dilog masuk ke gedung Google Play pada AVD anda, dan mempunyai OpenGL ES 3.0 atau yang lebih tinggi diaktifkan.

Untuk memeriksa sama ada OpenGL ES 3.0 atau lebih tinggi kini didayakan pada AVD anda:

Lancarkan AVD anda, seperti biasa.
Buka tetingkap Terminal baru (Mac) atau Prompt Perintah (Windows).
Tukar direktori ("cd") supaya Prompt Terminal / Perintah menunjuk pada lokasi program "adb" Android SDK anda, contohnya perintah saya kelihatan seperti ini:

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

Tekan kekunci "Enter" pada papan kekunci anda.
Salin / tampal perintah seterusnya ke Terminal, dan kemudian tekan kekunci "Enter":

./adb logcat | grep eglMakeCurrent

Jika Terminal pulangan "ver 3 0" atau lebih tinggi, maka OpenGL ES dikonfigurasi dengan betul. Sekiranya Terminal atau Prompt Perintah memaparkan apa-apa lebih awal daripada 3.0, maka anda perlu mendayakan OpenGL ES 3.0:

Tukar kembali ke AVD anda.
Cari jalur butang "Kawalan Extended" yang terapung di samping Emulator Android, dan kemudian pilih "Tetapan> Lanjutan."
Navigasikan ke "Tahap API OpenGL ES> Renderer maksimum (sehingga OpenGL ES 3.1)."
Mulakan semula emulator.

Dalam tetingkap Terminal / Perintah Prompt, salin / tampal perintah berikut dan tekan kekunci "Enter"

./adb logcat | grep eglMakeCurrent

Anda kini akan mendapat keputusan "ver 3 0" atau lebih tinggi, yang bermaksud OpenGL ES dikonfigurasi dengan betul.

Akhir sekali, pastikan AVD anda menjalankan versi terbaru ARCore:

Kepala ke laman GitHub ARCore, dan muat turun pelepasan terbaru ARCore untuk emulator. Sebagai contoh, pada masa menulis pembebasan yang paling baru-baru ini adalah "ARCore_1.7.0.x86_for_emulator.apk"
Seret dan lepaskan APK ke AVD yang sedang berjalan.

Untuk menguji projek anda pada AVD, pasang aplikasi anda dan beri akses kepada "kamera" AVD apabila digesa.

Anda kini perlu melihat pandangan kamera bilik simulasi. Untuk menguji aplikasi anda, bergerak di ruang maya ini, cari permukaan rata simulasi, dan klik untuk meletakkan model di permukaan ini.

Anda boleh memindahkan kamera maya di sekitar bilik maya, dengan menekan dan menahan kekunci "Pilihan" (macOS) atau "Alt" (Linux atau Windows), dan kemudian menggunakan mana-mana pintasan papan kekunci berikut:

Bergerak ke kiri atau ke kanan. Tekan A atau D.
Gerakkan ke bawah atau ke atas. Tekan Q atau E.
Bergerak ke hadapan atau belakang. Tekan W atau S.

Anda juga boleh "bergerak" sekitar adegan maya, dengan menekan "Option" atau "Alt" dan kemudian menggunakan tetikus anda. Ini boleh merasakan sedikit kikuk pada mulanya, tetapi dengan amalan anda harus berjaya meneroka ruang maya. Sebaik sahaja anda mencari pesawat simulasi, klik titik putih untuk meletakkan model 3D anda pada permukaan ini.

Mengakhiri

Dalam artikel ini, kami mencipta aplikasi realiti yang ditambah mudah, menggunakan ARCore dan plugin Sceneform.

Jika anda memutuskan untuk menggunakan Google ARCore dalam projek anda sendiri, maka pastikan anda berkongsi ciptaan anda dalam ulasan di bawah!