Nilalaman

• Pag-import ng mga modelo ng 3D, gamit ang Sceneform plugin
• Pag-install ng plugin Sceneform
• Sceneform UX at Java 8: Ina-update ang iyong mga dependency sa proyekto
• Humihiling ng mga pahintulot na may ArFragment
• Kinakailangan o Opsyonal na AR?
• 1. AR Kinakailangan
• 2. AR Opsyonal
• Magdagdag ng ArFragment sa iyong layout
• Pag-download ng mga modelo ng 3D, gamit ang Google ng Poly
• Ang pag-import ng mga 3D na modelo sa Android Studio
• Ipakita ang iyong 3D na modelo
• 1. Lumikha ng isang variable na miyembro ng ArFragment
• 2. Bumuo ng isang ModelRenderable
• 3. Tumugon sa input ng gumagamit
• 4. Anchor ang iyong modelo
• 5. Magdagdag ng suporta para sa paglipat, pag-scale at pag-ikot
• Ang nakumpleto na MainActivity
• Pagsubok sa iyong Google ARCore pinalaki reality app
• Pagsubok ARCore sa isang Android Virtual Device
• Pagputol

Pag-import ng mga modelo ng 3D, gamit ang Sceneform plugin

Karaniwan, ang pakikipagtulungan sa mga modelong 3D ay nangangailangan ng kaalaman sa espesyalista, ngunit sa paglabas ng Sceneform plugin ay nagawa ng Google na mag-render ng mga modelong 3D gamit ang Java - at wala pagkakaroon upang malaman ang OpenGL.

Ang Sceneform plugin ay nagbibigay ng isang mataas na antas ng API na maaari mong magamit upang lumikha ng mga Renderdables mula sa mga karaniwang mga widget ng Android, mga hugis, o mga materyales, o mula sa mga pag-aari ng 3D, tulad ng .OBJ o .FBX file.

Sa aming proyekto, gumagamit kami ng plugin ng Sceneform upang mag-import ng isang .OBJ file sa Android Studio. Sa tuwing mag-import ka ng isang file gamit ang Sceneform, awtomatikong awtomatikong ang plugin na ito:

• I-convert ang file ng asset sa isang .sfb file. Ito ay isang format na na-optimize ng Sceneform Binary na format (.sfb) na naidagdag sa iyong APK at pagkatapos ay nai-load sa runtime. Gagamitin namin ang file na ito .sfb upang lumikha ng isang Renderable, na binubuo ng mga meshes, materyales at texture, at maaaring mailagay kahit saan sa loob ng pinalaki na eksena.
• Bumuo ng isang .sfa file. Ito ay isang file na paglalarawan ng asset, na isang file ng teksto na naglalaman ng isang madaling mabasa ng paglalarawan ng file na .sfb. Depende sa modelo, maaari mong baguhin ang hitsura nito sa pamamagitan ng pag-edit ng teksto sa loob ng .sfa file.

Magkaroon lamang ng kamalayan na sa oras ng pagsulat, ang Sceneform plugin ay nasa beta pa, kaya maaari kang makatagpo ng mga bug, error, o iba pang kakaibang pag-uugali kapag gumagamit ng plugin na ito.

Pag-install ng plugin Sceneform

Ang Sceneform plugin ay nangangailangan ng Android Studio 3.1 o mas mataas. Kung hindi ka sigurado kung aling bersyon ng Android Studio ang iyong ginagamit, piliin ang "Android Studio> Tungkol sa Android Studio" mula sa toolbar. Ang kasunod na popup ay naglalaman ng ilang pangunahing impormasyon tungkol sa iyong pag-install sa Android Studio, kasama ang numero ng bersyon nito.

Upang mai-install ang plugin Sceneform:

• Kung ikaw ay nasa isang Mac, piliin ang "Android Studio> Mga Kagustuhan ..." mula sa tool ng Android Studio, pagkatapos ay pumili ng "Mga Plugin" mula sa kaliwang menu. Kung ikaw ay nasa isang Windows PC, pagkatapos ay piliin ang "File> Mga setting> Mga plugin> Mag-browse ng mga repositori."
• Maghanap para sa "Sceneform." Kapag lumitaw ang "Mga tool sa Google Sceneform", piliin ang "I-install."
• I-restart ang Android Studio kapag sinenyasan, at handa nang gamitin ang iyong plugin.

Sceneform UX at Java 8: Ina-update ang iyong mga dependency sa proyekto

Magsimula tayo sa pamamagitan ng pagdaragdag ng mga dependencies na magagamit namin sa buong proyektong ito. Buksan ang iyong file-level build.gradle file, at idagdag ang library ng Sceneform UX, na naglalaman ng ArFragment na gagamitin namin sa aming layout:

dependencies {pagpapatupad fileTree (dir: libs, may kasamang:) pagpapatupad ng androidx.appcompat: appcompat: 1.0.2 pagpapatupad ng 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 ay nagbibigay ng mga mapagkukunan ng UX, kabilang ang ArFragment // implementasyon "com.google.ar.sceneform.ux: sceneform-ux: 1.7.0" pagpapatupad "com. android.support:appcompat-v7:28.0.0 "}

Gumagamit ang Sceneform ng mga konstruksyon ng wika mula sa Java 8, kaya kakailanganin din nating i-update ang Compatibility ng aming proyekto at Pagkatugma sa Target sa Java 8:

compileOptions {sourceCompatibility JavaVersion.VERSION_1_8 targetCompatibility JavaVersion.VERSION_1_8}

Sa wakas, kailangan nating ilapat ang Sceneform plugin:

mag-apply ng plugin: com.google.ar.sceneform.plugin

Ang iyong nakumpletong file na build.gradle ay dapat magmukhang ganito:

mag-apply ng plugin: com.android.application android {compileSdkVersion 28 defaultConfig {applicationId "com.jessicathornsby.arcoredemo" minSdkVersion 23 targetSdkVersion 28 bersyonCode 1 bersyonName "1.0" testInstrumentationRunner "androidx.test.runner.AndroidJUnitRg. JavaVersion.VERSION_1_8} buildTypes {release {minifyEnabled false proguardFiles getDefaultProguardFile (proguard-android-optimize.txt), proguard-rules.pro}}} dependencies {pagpapatupad fileTree (dir: libs, kasama ang:) pagpapatupad ng androidx.appcompat: appcompat: .2 pagpapatupad ng androidx.constraintlayout: paghihigpit: 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 pagpapatupad "com.google. ar.sceneform.ux: sceneform-ux: 1.7.0 "pagpapatupad" com.android.support:appcompat-v7:28.0.0 "} mag-apply ng plugin: com.google.ar .sceneform.plugin

Humihiling ng mga pahintulot na may ArFragment

Gagamitin ng aming application ang camera ng aparato upang pag-aralan ang mga paligid at posisyon ng mga 3D na modelo sa totoong mundo. Bago mai-access ang aming application sa camera, nangangailangan ito ng pahintulot ng camera, kaya buksan ang Manifest ng iyong proyekto at idagdag ang sumusunod:

Binigyan ng Android 6.0 ang mga gumagamit ng kakayahang magbigay, tanggihan at bawiin ang mga pahintulot sa isang batayan ng pahintulot-by-pahintulot. Habang napabuti nito ang karanasan ng gumagamit, ang mga developer ng Android ngayon ay manu-mano na humiling ng mga pahintulot sa runtime, at hawakan ang tugon ng gumagamit. Ang mabuting balita ay kapag nagtatrabaho ang Google ARCore, ang proseso ng paghingi ng pahintulot ng camera at paghawak ng tugon ng gumagamit ay ipinatupad awtomatiko.

Ang sangkap na ArFragment ay awtomatikong susuriin kung ang iyong app ay may pahintulot sa camera at pagkatapos ay hiniling ito, kung kinakailangan, bago lumikha ng session ng AR. Dahil gumagamit kami ng ArFragment sa aming app, hindi namin kailangang sumulat ng anumang code upang humiling ng pahintulot sa camera.

Kinakailangan o Opsyonal na AR?

Mayroong dalawang uri ng mga application na gumagamit ng AR andar:

1. AR Kinakailangan

Kung ang iyong aplikasyon ay umaasa sa Google ARCore upang maihatid ang isang mahusay na karanasan sa gumagamit, kailangan mong tiyakin na na-download lamang ito sa mga aparato na sumusuporta sa ARCore. Kung minarkahan mo ang iyong app bilang "AR Kinakailangan" pagkatapos ay lilitaw lamang ito sa Google Play store, kung sinusuportahan ng aparato ang ARCore.

Dahil ang aming aplikasyon ay nangangailangan ng ARCore, buksan ang Manifest at idagdag ang sumusunod:

May pagkakataon ding ma-download ang iyong aplikasyon sa isang aparato na sumusuporta sa ARCore sa teorya, ngunit hindi talaga nai-install ang ARCore. Kapag minarkahan namin ang aming app bilang "AR Kinakailangan" Awtomatikong i-download at i-install ng Google Play ang ARCore sa tabi ng iyong app, kung wala pa ito sa target na aparato.

Magkaroon lamang ng kamalayan na kahit na ang iyong app ay android: kinakailangan = ”totoo” ay pa rin kailangang suriin na ang ARCore ay naroroon sa runtime, dahil mayroong isang pagkakataon na maaaring hindi mai-install ng gumagamit ang ARCore mula sa pag-download ng iyong app, o na ang kanilang bersyon ng ARCore ay wala sa oras.

Ang mabuting balita ay gumagamit kami ng ArFragment, na awtomatikong sinusuri na ang ARCore ay na-install at napapanahon bago lumikha ng bawat isa AR session - kaya sa sandaling muli, ito ay isang bagay na hindi namin kailangang ipatupad nang manu-mano.

2. AR Opsyonal

Kung kasama sa iyong app ang mga tampok na AR na maganda ngunit hindi mahalaga upang maihatid ang pangunahing pag-andar nito, pagkatapos ay maaari mong markahan ang application na ito bilang "AR Opsyonal." Maaring suriin ng iyong app kung ang Google ARCore ay naroroon sa runtime, at hindi paganahin ang Ang mga tampok ng AR sa mga aparato na hindi sumusuporta sa ARCore.

Kung gumawa ka ng isang "AR Opsyonal" na app, pagkatapos ARCore ay hindi awtomatikong mai-install sa tabi ng iyong aplikasyon, kahit na ang aparato ay mayroong lahat ng hardware at software na kinakailangan upang suportahan ang ARCore. Ang iyong "AR Opsyonal" na app ay kakailanganin suriin kung ang ARCore ay naroroon at napapanahon, at i-download ang pinakabagong bersyon bilang at kung kinakailangan.

Kung ang ARCore ay hindi mahalaga sa iyong app, maaari mong idagdag ang sumusunod sa iyong Manifest:

Habang binubuksan ko ang Manifest, nagdaragdag din ako ng android: configChanges at android: screenOrientation, upang matiyak na ang mga MainActivity ay humahawak sa oryentasyon ay nagbabago nang maganda.

Matapos idagdag ang lahat ng ito sa iyong Manifest, ang nakumpletong file ay dapat magmukhang katulad nito:

Magdagdag ng ArFragment sa iyong layout

Gumagamit ako ng ArFragment ng ARCore, dahil awtomatiko nitong hinahawakan ang isang bilang ng mga pangunahing gawain sa ARCore sa pagsisimula ng bawat session ng AR. Karamihan sa mga kapansin-pansin, Sinusuri ng ArFragment na ang isang katugmang bersyon ng ARCore ay naka-install sa aparato, at na ang app ay kasalukuyang may pahintulot sa camera.

Kapag napatunayan ng ArFragment na maaaring suportahan ng aparato ang AR tampok ng iyong app, lumilikha ito ng sesyon ng ArSceneView ARCore, at ang karanasan ng AR ng iyong app ay handa nang puntahan!

Maaari kang magdagdag ng fragment ng ArFragment sa isang layout ng file, tulad ng isang regular na Android Fragment, kaya buksan ang iyong activity_main.xml file at magdagdag ng isang bahagi ng "com.google.ar.sceneform.ux.ArFragment".

Pag-download ng mga modelo ng 3D, gamit ang Google ng Poly

Mayroong maraming iba't ibang mga paraan na maaari kang lumikha ng mga Renderable, ngunit sa artikulong ito ay gumagamit kami ng isang file na 3D asset.

Sinusuportahan ng Sceneform ang mga 3D assets sa .OBJ, .glTF, at mga format ng FFX, na mayroon o walang mga animation. Maraming lugar kung saan makakakuha ka ng mga 3D na modelo sa isa sa mga suportadong format na ito, ngunit sa tutorial na ito ay gumagamit ako ng isang .OBJ file, na na-download mula sa repositoryo ng Google.

Tumungo sa website ng Poly at i-download ang asset na nais mong gamitin, sa format na .OBJ (Gumagamit ako ng modelong T-Rex na ito).

• Alisin ang folder, na dapat maglaman ng file ng mapagkukunan ng iyong modelo (.OBJ, .FBX, o .glTF). Depende sa modelo, ang folder na ito ay maaari ring maglaman ng ilang mga dependency ng modelo, tulad ng mga file sa .mtl, .bin, .png, o .jpeg na format.

Ang pag-import ng mga 3D na modelo sa Android Studio

Kapag mayroon ka ng iyong pag-aari, kailangan mong i-import ito sa Android Studio gamit ang Sceneform plugin. Ito ay isang proseso ng maraming hakbang na nangangailangan sa iyo upang:

• Lumikha ng isang folder na "sampledata" Ang Sampledata ay isang bagong uri ng folder para sa data ng sample ng oras ng disenyo na hindi kasama sa iyong APK, ngunit magagamit sa editor ng Android Studio.
• I-drag at i-drop ang orihinal na .OBJ asset file sa iyong "sampledata" folder.
• Gawin ang pag-import ng Sceneform at pag-convert sa .OBJ file, na bubuo ng .sfa at .sfb file.

Bagaman mukhang mas prangka ito, huwag i-drag at i-drop ang .OBJ file nang direkta sa direktoryo ng "res" ng iyong proyekto, dahil ito ang magiging sanhi ng modelo na maisama sa iyong APK nang hindi kinakailangan.

Ang mga proyekto sa Android Studio ay hindi naglalaman ng isang folder na "sampledata" bilang default, kaya kakailanganin mong lumikha ng isang mano-mano:

• Kontrol-click ang folder ng "app" ng iyong proyekto.
• Piliin ang "Bago> Halimbawang Data Directory" at lumikha ng isang folder na pinangalanang "sampledata."
• Mag-navigate sa mga file ng 3D model na na-download mo nang mas maaga. Hanapin ang file ng mapagkukunan ng mapagkukunan (.OBJ, .FBX, o .glTF) at pagkatapos ay i-drag at ihulog ito sa direktoryong "sampledata".
• Suriin kung ang iyong modelo ay may anumang mga dependencies (tulad ng mga file sa .mtl, .bin, .png, o .jpeg format). Kung nahanap mo ang alinman sa mga file na ito, pagkatapos ay i-drag at i-drop ang mga ito sa folder na "sampledata".
• Sa Android Studio, i-click ang Control-click ang iyong file ng modelong 3D (.OBJ, .FBX, o .glTF) at pagkatapos ay piliin ang "I-import ang Sceneform Asset."

• Ang kasunod na window ay nagpapakita ng ilang impormasyon tungkol sa mga file na mai-develop ng Sceneform, kabilang ang kung saan ang nagreresulta .sfa file ay maiimbak sa iyong proyekto; Ako ay gumagamit ng direktoryo na "hilaw".
• Kapag nasiyahan ka sa impormasyong iyong naipasok, i-click ang "Tapos na."

Ang pag-import na ito ay gumagawa ng ilang mga pagbabago sa iyong proyekto. Kung bubuksan mo ang iyong file ng build.gradle, makikita mo na ang Sceneform plugin ay naidagdag bilang isang dependant ng proyekto:

dependencies {classpath com.android.tools.build:gradle pony.5.0-alpha06 classpath com.google.ar.sceneform: plugin: 1.7.0 // TANDAAN: Huwag ilagay ang iyong mga dependency sa aplikasyon dito; kabilang sila // sa indibidwal na module build.gradle file}}

Buksan ang iyong file-level build.gradle file, at makakahanap ka ng isang bagong eksena ng eksena.asset () para sa iyong nai-import na modelo ng 3D:

mag-apply ng plugin: com.google.ar.sceneform.plugin // Ang "Source Asset Path" na tinukoy mo sa pag-import // sceneform.asset (sampledata / dinosaur.obj, // Ang "Material Land" na iyong tinukoy sa panahon ng pag-import // Default , // Ang ".sfa Output Path" na iyong tinukoy sa pag-import // sampledata / dinosaur.sfa, // Ang ".sfb Output Path" na tinukoy mo sa pag-import // src / pangunahing / assets / dinosaur)

Kung titingnan mo ang iyong "sampledata" at "hilaw" na folder, makikita mo makikita na naglalaman ang mga ito ng mga bagong .sfa at .sfb file, ayon sa pagkakabanggit.

Maaari mong i-preview ang .sfa file, sa bagong Sceneform Viewer ng Android Studio:

• Piliin ang "Tingnan> Mga tool sa Windows> Viewer" mula sa bar sa menu ng Android Studio.
• Sa kaliwang menu, piliin ang iyong .sfa file. Ang iyong 3D na modelo ay dapat na lumitaw ngayon sa window ng Viewer.

Ipakita ang iyong 3D na modelo

Ang aming susunod na gawain ay ang paglikha ng isang session AR na nauunawaan ang mga paligid nito, at pinapayagan ang gumagamit na maglagay ng mga modelo ng 3D sa isang pinalaki na tanawin.

Ito ay nangangailangan sa amin na gawin ang mga sumusunod:

1. Lumikha ng isang variable na miyembro ng ArFragment

Ginagawa ng ArFragment ang karamihan sa mabibigat na pag-angat na kasangkot sa paglikha ng isang session sa AR, kaya isasangguni namin ang fragment na ito sa buong klase ng MainActivity.

Sa mga sumusunod na snippet, lumilikha ako ng isang variable ng miyembro para sa ArFragment at pagkatapos ay inumpisahan ito sa pamamaraang onCreate ():

pribadong ArFragment arCoreFragment; Protektado ng @Override na walang bisa saCreate (Bundle saveInstanceState) {super.onCreate (saveInstanceState); ... ... ...} setContentView (R.layout.activity_main); arCoreFragment = (ArFragment) // Hanapin ang fragment, gamit ang fragment manager // getSupportFragmentManager (). findFragmentById (R.id.main_fragment);

2. Bumuo ng isang ModelRenderable

Kailangan nating baguhin ang aming .sfb file sa isang ModelRenderable, na sa kalaunan ay ibigay ang aming 3D na bagay.

Dito, lumilikha ako ng isang ModelRenderable mula sa res / raw / dinosaur file ng aking proyekto:

pribadong ModelRenderable dinoRenderable; ... ... ... ModelRenderable.builder () .setSource (ito, R.raw.dinosaur) .build () .thenAccept (renderable -> dinoRenderable = renderable) .exceptionally (throwable -> {Log.e ( TAG, "Hindi ma-load renderable"); return null;}); }

3. Tumugon sa input ng gumagamit

Ang ArFragment ay may built-in na suporta para sa gripo, pag-drag, kurot, at twist na mga kilos.

Sa aming app, ang gumagamit ay magdagdag ng isang 3D na modelo sa isang ARCore Plane, sa pamamagitan ng pagbibigay ng eroplano na isang gripo.

Upang maihatid ang pagpapaandar na ito, kailangan nating magrehistro ng isang callback na mai-invoke tuwing may eroplano na naka-tap:

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

4. Anchor ang iyong modelo

Sa hakbang na ito, kukuha kami ng isang ArSceneView at ilakip ito sa isang AnchorNode, na magsisilbing node ng magulang ng Scene.

Ang ArSceneView ay may pananagutan sa pagsasagawa ng maraming mahahalagang gawain ng ARCore, kasama ang pag-render ng mga imahe ng camera ng aparato, at pagpapakita ng isang Sceneform UX animation na nagpapakita kung paano dapat hawakan at ilipat ng gumagamit ang kanilang aparato upang masimulan ang karanasan AR. Ang ArSceneView ay magtatampok din ng anumang mga eroplano na nakita nito, handa na upang ilagay ng gumagamit ang kanilang mga 3D na modelo sa loob ng eksena.

Ang sangkap ng ARSceneView ay may isang Scene na nakakabit dito, na kung saan ay isang istraktura ng data ng magulang-anak na naglalaman ng lahat ng mga Node na kailangang ma-render.

Magsisimula kami sa pamamagitan ng paglikha ng isang node ng uri ng AnchorNode, na kikilos bilang aming node ng ArSceneView's.

Ang lahat ng mga node ng angkla ay mananatili sa parehong tunay na posisyon sa mundo, kaya sa pamamagitan ng paglikha ng isang node ng angkla tinitiyak namin na ang aming mga 3D na modelo ay mananatiling maayos sa lugar sa loob ng pinalaki na tanawin.

Gawin natin ang aming anchor node:

AnchorNode anchorNode = bagong AnchorNode (angkla);

Pagkatapos ay maaari nating makuha ang isang ArSceneView, gamit ang getArSceneView (), at ikabit ito sa AnchorNode:

angklaNode.setParent (arCoreFragment.getArSceneView (). makakuha ngScene ());

5. Magdagdag ng suporta para sa paglipat, pag-scale at pag-ikot

Susunod, gagawa ako ng isang node ng uri na TransformableNode. Ang TransformableNode ay responsable para sa paglipat, pag-scale at pag-ikot ng mga node, batay sa mga galaw ng gumagamit.

Kapag nakagawa ka ng TransformableNode, maaari mo itong ilakip ang Renderable, na magbibigay sa modelo ng kakayahang masukat at ilipat, batay sa pakikisalamuha ng gumagamit. Sa wakas, kailangan mong ikonekta ang TransformableNode sa AnchorNode, sa relasyon ng isang magulang-anak na nagsisiguro sa TransformableNode at Renderable mananatiling maayos sa lugar sa loob ng pinalaki na tanawin.

TransformableNode nababagoNode = bagong TransformableNode (arCoreFragment.getTransformSystem ()); // Ikonekta ang nababagoNode sa anchorNode // nababagoNode.setParent (anchorNode); nababagoNode.setRenderable (dinoRenderable); // Piliin ang node // mababagoNode.select (); }); }

Ang nakumpleto na MainActivity

Matapos maisagawa ang lahat ng nasa itaas, ang iyong MainActivity ay dapat magmukhang ganito:

i-import ang android.app.Activity; i-import ang android.app.ActivityManager; i-import ang androidx.appcompat.app.AppCompatActivity; mag-import ng android.content.Context; i-import ang android.net.Uri; i-import ang android.os.Build; i-import ang android.os.Build.VERSION_CODES; i-import ang android.os.Bundle; i-import ang android.util.log; i-import ang android.view.MotionEvent; i-import ang androidx.annotation.RequiresApi; i-import ang com.google.ar.core.Anchor; import ng com.google.ar.core.HitResult; import ng 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; pampublikong klase MainActivity ay umaabot ng AppCompatActivity {pribadong static panghuling String TAG = MainActivity.class.getSimpleName (); pribadong static na panghuling dobleng MIN_OPENGL_VERSION = 3.0; // Lumikha ng isang variable ng miyembro para sa ModelRenderable // pribadong ModelRenderable dinoRenderable; // Lumikha ng isang variable ng miyembro para sa ArFragment // pribadong ArFragment arCoreFragment; @RequiresApi (api = VERSION_CODES.N) @Override protektado walang bisa saCreate (Bundle saveInstanceState) {super.onCreate (saveInstanceState); kung (! checkDevice ((ito))) {bumalik; } setContentView (R.layout.activity_main); arCoreFragment = (ArFragment) // Hanapin ang fragment, gamit ang fragment manager // getSupportFragmentManager (). findFragmentById (R.id.main_fragment); kung (Bumuo.VERSION.SDK_INT> = VERSION_CODES.N) {// Buuin ang ModelRenderable // ModelRenderable.builder () .setSource (ito, R.raw.dinosaur) .build () .thenAccept (renderable -> dinoRenderable = renderable ) .exceptionally (// Kung naganap ang isang error ... // itatapon -> {//... pagkatapos ay i-print ang sumusunod sa Logcat // Log.e (TAG, "Hindi ma-load renderable"); return null;} ); } // Makinig para sa mga kaganapan saTap // arCoreFragment.setOnTapArPlaneListener ((HitResult hitResult, eroplano Plane, MotionEvent motionEvent) -> {kung (dinoRenderable == null) {return;} Anchor anchor = hitResult.createAnchor (); // node ng uri AnchorNode // AnchorNode anchorNode = bagong AnchorNode (angkla); // Ikonekta ang AnchorNode sa Scene // anchorNode.setParent (arCoreFragment.getArSceneView (). getScene ()); // Bumuo ng isang node ng uri na TransformableNode // TransformableNode transformableNode = bagong TransformableNode (arCoreFragment.getTransformSystem ()); // Ikonekta ang TransformableNode sa AnchorNode // transformableNode.setParent (anchorNode); // Ikabit ang Renderable // transformableNode.setRenderable (dinoRenderable); // Itakda ang nerbiyos / nababagoNode.select ();}); } pampublikong static boolean checkDevice (panghuling aktibidad ng Aktibidad) {// Kung ang aparato ay nagpapatakbo ng Android Marshmallow o mas maaga ... // kung (Buuin.VERSION.SDK_INT <VERSION_CODES.N) {//... pagkatapos ay i-print ang sumusunod sa Logcat // Log.e (TAG, "Sceneform ay nangangailangan ng Android N o mas mataas"); aktibidad.finish (); bumalik mali; } String openGlVersionString = ((AktibidadManager) aktibidad.getSystemService (Context.ACTIVITY_SERVICE)) .getDeviceConfigurasiInfo () // Suriin ang bersyon ng OpenGL ES // .getGlEsVersion (); // Kung ang aparato ay nagpapatakbo ng anumang mas mababa sa OpenGL ES 3.0 ... // kung (Double.parseDouble (openGlVersionString) <MIN_OPENGL_VERSION) {//... pagkatapos ay i-print ang sumusunod sa Logcat // Log.e (TAG, " Nangangailangan ng OpenGL ES 3.0 o mas mataas na "); aktibidad.finish (); bumalik mali; } bumalik totoo; }}

Maaari mong i-download ang nakumpletong proyekto mula sa GitHub.

Pagsubok sa iyong Google ARCore pinalaki reality app

Handa ka na upang subukan ang iyong aplikasyon sa isang pisikal, suportado na aparato ng Android. Kung hindi ka nagmamay-ari ng isang aparato na sumusuporta sa ARCore, posible na subukan ang iyong AR app sa Android Emulator (na may kaunting dagdag na pagsasaayos, na tatakip kami sa susunod na seksyon).

Upang subukan ang iyong proyekto sa isang pisikal Aparato ng Android:

• I-install ang iyong aplikasyon sa target na aparato.
• Kapag sinenyasan, bigyan ng access ang application sa camera ng iyong aparato.
• Kung sinenyasan upang mai-install o i-update ang ARCore app, tapikin ang "Magpatuloy" at pagkatapos ay kumpletuhin ang diyalogo upang matiyak na nagpapatakbo ka ng pinakabago at pinakadakilang bersyon ng ARCore.
• Dapat mo na ngayong makita ang isang pagtingin sa camera, kumpleto sa isang animation ng isang kamay na may hawak na aparato. Ituro ang camera sa isang patag na ibabaw at ilipat ang iyong aparato sa isang pabilog na paggalaw, tulad ng ipinakita ng animation. Pagkaraan ng ilang sandali, dapat lumitaw ang isang serye ng mga tuldok, na nagpapahiwatig na ang isang eroplano ay napansin.

• Kapag nasiyahan ka sa posisyon ng mga tuldok na ito, bigyan sila ng gripo - ang iyong 3D na modelo ay dapat na lumitaw ngayon sa iyong napiling eroplano!

• Subukan ang pisikal na paglipat sa paligid ng modelo; depende sa iyong paligid, maaari mong gawin ang buong 360 degree sa paligid nito. Dapat mo ring suriin na ang bagay ay naglalagay ng anino na naaayon sa tunay na mapagkukunan ng mundo ng ilaw.

Pagsubok ARCore sa isang Android Virtual Device

Upang subukan ang iyong mga ARCore apps sa isang Android Virtual Device (AVD), kakailanganin mo ang bersyon ng Android Emulator 27.2.9 o mas mataas. Dapat ka ring mag-sign in sa Google Play store sa iyong AVD, at magkaroon ng OpenGL ES 3.0 o mas mataas na pagana.

Upang masuri kung ang OpenGL ES 3.0 o mas mataas ay kasalukuyang pinagana sa iyong AVD:

• Ilunsad ang iyong AVD, bilang normal.
• Magbukas ng bagong window ng Terminal (Mac) o isang Command Prompt (Windows).
• Baguhin ang direktoryo ("cd") kaya tinuturo ng Terminal / Command Prompt ang lokasyon ng "adb" na programa ng iyong SD SDK, halimbawa tulad ng aking utos:

Cd / Gumagamit / jessicathornsby / Library / Android / sdk / platform-tool

• Pindutin ang "Enter" key sa iyong keyboard.
• Kopyahin / idikit ang susunod na utos sa Terminal, at pagkatapos ay pindutin ang "Enter" key:

./adb logcat | grep eglMakeCurrent

Kung ang Terminal ay nagbabalik ng "ver 3 0" o mas mataas, pagkatapos ay isinaayos nang tama ang OpenGL ES. Kung ang Terminal o Command Prompt ay nagpapakita ng anumang mas maaga kaysa sa 3.0, kakailanganin mong paganahin ang OpenGL ES 3.0:

• Bumalik sa iyong AVD.
• Hanapin ang strip ng "Extended Control" na mga pindutan na lumulutang sa tabi ng Android Emulator, at pagkatapos ay piliin ang "Mga Setting> Advanced."
• Mag-navigate sa "antas ng OpenGL ES API> maximum na renderer (hanggang sa OpenGL ES 3.1)."
• I-restart ang emulator.

Sa window ng Terminal / Command Prompt, kopyahin / ilagay ang sumusunod na utos at pagkatapos ay pindutin ang "Enter" key "

./adb logcat | grep eglMakeCurrent

Kailangan mo na ngayong makakuha ng isang resulta ng "ver 3 0" o mas mataas, na nangangahulugan na ang OpenGL ES ay na-configure nang tama.

Sa wakas, siguraduhin na ang iyong AVD ay nagpapatakbo ng pinakabagong bersyon ng ARCore:

• Tumungo sa pahina ng GitHub ng ARCore, at i-download ang pinakabagong paglabas ng ARCore para sa emulator. Halimbawa, sa pagsulat ng pinakahuling paglabas ay "ARCore_1.7.0.x86_for_emulator.apk"
• I-drag at i-drop ang APK sa iyong pagpapatakbo ng AVD.

Upang masubukan ang iyong proyekto sa isang AVD, i-install ang iyong aplikasyon at bigyan ito ng access sa "camera" ng AVD kapag sinenyasan.

Dapat mo na ngayong makita ang isang pagtingin sa camera ng isang kunwa na silid. Upang masubukan ang iyong aplikasyon, ilipat sa paligid ng virtual space na ito, maghanap ng isang kunwa flat na ibabaw, at i-click upang maglagay ng isang modelo sa ibabaw na ito.

Maaari mong ilipat ang virtual camera sa paligid ng virtual na silid, sa pamamagitan ng pagpindot at paghawak ng "Opsyon" (macOS) o "Alt" (Linux o Windows) key, at pagkatapos ay gamit ang alinman sa mga sumusunod na mga shortcut sa keyboard:

• Ilipat pakaliwa o pakanan. Pindutin ang A o D.
• Bumaba o pataas. Pindutin ang Q o E.
• Sumulong o pabalik. Pindutin ang W o S.

Maaari mo ring "ilipat" sa paligid ng virtual na eksena, sa pamamagitan ng pagpindot sa "Pagpipilian" o "Alt" at pagkatapos ay gamit ang iyong mouse. Ito ay maaaring makaramdam ng isang maliit na clunky sa una, ngunit sa pagsasanay dapat mong matagumpay na tuklasin ang virtual na puwang. Kapag nakakita ka ng isang kunwa na eroplano, i-click ang mga puting tuldok upang ilagay ang iyong 3D na modelo sa ibabaw na ito.

Pagputol

Sa artikulong ito, lumikha kami ng isang simpleng pinalaki na reality app, gamit ang ARCore at ang Sceneform plugin.

Kung magpasya kang gamitin ang Google ARCore sa iyong sariling mga proyekto, siguraduhing ibahagi ang iyong mga likha sa mga komento sa ibaba!