Saturs

• 3D modeļu importēšana ar spraudni Sceneform
• Sceneform spraudņa instalēšana
• Sceneform UX un Java 8: projekta atkarību atjaunināšana
• Lūgumu pieprasīšana, izmantojot ArFragment
• AR ir nepieciešams vai nav obligāts?
• 1. AR nepieciešams
• 2. AR nav obligāts
• Pievienojiet ArFragment savam izkārtojumam
• Lejupielādējiet 3D modeļus, izmantojot Google Poly
• 3D modeļu importēšana Android Studio
• Parādiet savu 3D modeli
• 1. Izveidojiet ArFragment dalībnieka mainīgo
• 2. Veidojiet modeli, kuru var remontēt
• 3. Atbildiet uz lietotāja ievadi
• 4. Noenkurojiet modeli
• 5. Pievienojiet atbalstu pārvietošanai, mērogošanai un pagriešanai
• Pabeigtā MainActivity
• Pārbaudiet savu Google ARCore paplašinātās realitātes lietotni
• ARCore testēšana Android virtuālajā ierīcē
• Iesaiņošana

3D modeļu importēšana ar spraudni Sceneform

Parasti darbam ar 3D modeļiem ir vajadzīgas speciālistu zināšanas, taču, atbrīvojot spraudni Sceneform, Google ir ļāvis 3D modeļus atveidot, izmantojot Java - un bez jāapgūst OpenGL.

Sceneform spraudnis nodrošina augsta līmeņa API, kuru varat izmantot, lai izveidotu Renderdables no standarta Android logrīkiem, formām vai materiāliem vai no 3D aktīviem, piemēram, .OBJ vai .FBX failiem.

Savā projektā mēs izmantosim spraudni Sceneform, lai .OBJ failu importētu Android Studio. Kad importējat failu, izmantojot Sceneform, šis spraudnis automātiski:

• Pārvērtiet aktīvu failu .sfb failā. Šis ir izpildlaika režīmā optimizēts ainas binārais formāts (.sfb), kas tiek pievienots jūsu APK un pēc tam ielādēts izpildlaikā. Mēs izmantosim šo .sbb failu, lai izveidotu Renderējamu, kas sastāv no acīm, materiāliem un faktūrām un ko var ievietot jebkur paplašinātajā skatu vietā.
• Ģenerējiet .sfa failu. Šis ir aktīvu apraksta fails, kas ir teksta fails, kas satur cilvēkam lasāmu .sfb faila aprakstu. Atkarībā no modeļa, iespējams, varēsit mainīt tā izskatu, rediģējot tekstu .sfa failā.

Tikai ņemiet vērā, ka rakstīšanas laikā Sceneform spraudnis joprojām bija beta versijā, tāpēc, lietojot šo spraudni, jūs varat saskarties ar kļūdām, kļūdām vai citu dīvainu uzvedību.

Sceneform spraudņa instalēšana

Sceneform spraudnim nepieciešama operētājsistēmas Android Studio 3.1 vai jaunāka versija. Ja neesat pārliecināts, kuru Android Studio versiju izmantojat, rīkjoslā atlasiet “Android Studio> Par Android Studio”. Nākamais uznirstošais logs satur pamatinformāciju par jūsu Android Studio instalēšanu, ieskaitot tās versijas numuru.

Lai instalētu Sceneform spraudni:

• Ja izmantojat Mac datoru, Android Studio rīkjoslā atlasiet “Android Studio> Preferences…” un kreisās puses izvēlnē izvēlieties “Spraudņi”. Ja izmantojat Windows datoru, atlasiet “Fails> Iestatījumi> Spraudņi> Pārlūkot krātuves”.
• Meklējiet “Sceneform”. Kad parādās “Google Sceneform Tools”, atlasiet “Install”.
• Restartējiet Android Studio, kad tas tiek prasīts, un jūsu spraudnis būs gatavs lietošanai.

Sceneform UX un Java 8: projekta atkarību atjaunināšana

Sāksim ar to, ka pievienojam atkarības, kuras mēs izmantosim visā šajā projektā. Atveriet savu moduļa līmeņa build.gradle failu un pievienojiet Sceneform UX bibliotēku, kurā ir ArFragment, kuru mēs izmantosim mūsu izkārtojumā:

atkarības {ieviešanas failsTreši (direktorijā: libs, iekļaujiet:) ieviešanu androidx.appcompat: appcompat: 1.0.2 ieviešana androidx.constraintlayout: ierobežojumu izpildīšana: 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 nodrošina UX resursus, ieskaitot ArFragment // ieviešanu "com.google.ar.sceneform.ux: sceneform-ux: 1.7.0" implementation "com. android.support:appcompat-v7:28.0.0 "}

Sceneform izmanto valodas konstrukcijas no Java 8, tāpēc mums būs jāatjaunina arī mūsu projekta avotu saderība un mērķa saderība ar Java 8:

compileOptions {sourceCompatibility JavaVersion.VERSION_1_8 targetCompatibility JavaVersion.VERSION_1_8}

Visbeidzot, mums jāpielieto spraudnis Sceneform:

lietot spraudni: com.google.ar.sceneform.plugin

Pabeigtajam failam build.gradle vajadzētu izskatīties šādi:

lietot spraudni: com.android.application android {compileSdkVersion 28 defaultConfig {applicationId "com.jessicathornsby.arcoredemo" minSdkVersion 23 targetSdkVersion 28 versionCode 1 versionName "1.0" testInstrumentationRunner "androidx.test.ReserverCommunities.ComprivationAndroidJunner CommandionAndroidJunner Computers JavaVersion.VERSION_1_8} buildTypes {release {minifyEnabled false proguardFiles getDefaultProguardFile (proguard-android-optimize.txt), proguard-rules.pro}}} atkarības {implementation fileTree (dir: libs, ietver:) ieviešana androidx.appcompat: appcompatpat: appcompatpat: appcompatpat .2 ieviešana 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: sceneform-ux: 1.7.0 "implementācija" com.android.support:appcompat-v7:28.0.0 "} lietot spraudni: com.google.ar .sceneform.plugin

Lūgumu pieprasīšana, izmantojot ArFragment

Mūsu lietojumprogramma izmantos ierīces kameru, lai analizētu apkārtni un novietotu 3D modeļus reālajā pasaulē. Lai mūsu lietojumprogramma varētu piekļūt kamerai, tai nepieciešama kameras atļauja, tāpēc atveriet projekta Manifest un pievienojiet šo:

Android 6.0 lietotājiem deva iespēju piešķirt, noraidīt un atsaukt atļaujas, pamatojoties uz atļauju. Kaut arī tas uzlaboja lietotāju pieredzi, Android izstrādātājiem tagad ir manuāli jāpieprasa atļaujas izpildlaikā un jārīkojas ar lietotāja atbildi. Labā ziņa ir tā, ka, strādājot ar Google ARCore, tiek ieviests kameras atļaujas pieprasīšanas un lietotāja atbildes apstrādes process. automātiski.

Komponents ArFragment automātiski pārbauda, ​​vai jūsu lietotnei ir kameras atļauja, un pēc tam pieprasa to pirms AR sesijas izveidošanas. Tā kā savā lietotnē izmantosim ArFragment, mums nav jāraksta kods, lai pieprasītu kameras atļauju.

AR ir nepieciešams vai nav obligāts?

Ir divu veidu lietojumprogrammas, kas izmanto AR funkcionalitāti:

1. AR nepieciešams

Ja jūsu lietojumprogramma ir balstīta uz Google ARCore, lai nodrošinātu labu lietotāja pieredzi, jums jāpārliecinās, ka tā vienmēr tiek lejupielādēta tikai ierīcēs, kas atbalsta ARCore. Ja atzīmējat savu lietotni kā “AR nepieciešama”, tā Google Play veikalā parādīsies tikai tad, ja ierīce atbalsta ARCore.

Kopš mūsu pieteikuma dara pieprasīt ARCore, atveriet manifestu un pievienojiet sekojošo:

Pastāv arī iespēja, ka jūsu lietojumprogramma var tikt lejupielādēta ierīcē, kas teorētiski atbalsta ARCore, taču faktiski tajā nav instalēta ARCore. Tiklīdz mēs atzīmēsim savu lietotni kā “AR obligātu”, Google Play automātiski lejupielādēs un instalēs ARCore blakus jūsu lietotnei, ja tā vēl nav paredzēta mērķa ierīcē.

Tikai ņemiet vērā, ka pat tad, ja jūsu lietotne ir android: obligāti = “patiesi”, jūs to darīsit joprojām jāpārbauda, ​​vai ARCore darbojas izpildlaikā, jo pastāv iespēja, ka lietotājs kopš jūsu lietotnes lejupielādes ir atinstalējis ARCore, vai arī viņa ARCore versija ir novecojusi.

Labā ziņa ir tā, ka mēs izmantojam ArFragment, kas pirms izveides automātiski pārbauda, ​​vai ARCore ir instalēts un atjaunināts. katrs AR sesija - tātad atkal tas ir kaut kas, kas mums nav jāievieš manuāli.

2. AR nav obligāts

Ja jūsu lietotnē ir ietvertas AR funkcijas, kuras ir jauki iegādāties, bet nav būtiskas, lai nodrošinātu tās galveno funkcionalitāti, varat atzīmēt šo lietojumprogrammu kā “AR izvēles”. Pēc tam jūsu lietotne var pārbaudīt, vai Google ARCore darbojas izpildlaikā, un atspējot tās AR funkcijas ierīcēs, kas neatbalsta ARCore.

Ja jūs izveidojat lietotni “AR izvēles”, tad ARCore to izveidos nē tiek automātiski instalēta blakus jūsu lietojumprogrammai, pat ja ierīcei ir visa aparatūra un programmatūra, kas nepieciešama ARCore atbalstam. Pēc tam jūsu lietotnei “AR papildaprīkojums” būs jāpārbauda, ​​vai ARCore ir pieejams un vai tā ir atjaunināta, un pēc vajadzības lejupielādējiet jaunāko versiju.

Ja ARCore nav izšķirošs jūsu lietotnei, manifestam varat pievienot šādus datus:

Kamēr man ir atvērts manifests, es pievienoju arī android: configChanges un android: screenOrientation, lai nodrošinātu, ka MainActivity graciozi apstrādā orientācijas izmaiņas.

Pēc tam, kad tas viss ir pievienots manifestā, pabeigtajam failam vajadzētu izskatīties apmēram šādi:

Pievienojiet ArFragment savam izkārtojumam

Es izmantošu ARCore ArFragment, jo katras AR sesijas sākumā tas automātiski apstrādā vairākus galvenos ARCore uzdevumus. Īpaši svarīgi, ArFragment pārbauda, ​​vai ierīcē ir instalēta saderīga ARCore versija un vai lietotnei pašlaik ir kameras atļauja.

Kad ArFragment ir pārliecinājies, ka ierīce var atbalstīt jūsu lietotnes AR funkcijas, tā izveido ArSceneView ARCore sesiju, un jūsu lietotnes AR pieredze ir gatava!

ArFragment fragmentu var pievienot izkārtojuma failam, tāpat kā parastam Android fragmentam, tāpēc atveriet savu darbības_main.xml failu un pievienojiet komponentu “com.google.ar.sceneform.ux.ArFragment”.

Lejupielādējiet 3D modeļus, izmantojot Google Poly

Atjaunojamos materiālus var izveidot dažādos veidos, taču šajā rakstā mēs izmantosim 3D aktīvu failu.

Sceneform atbalsta 3D aktīvus .OBJ, .glTF un .FBX formātos ar animācijām vai bez tām. Ir daudz vietu, kur varat iegādāties 3D modeļus vienā no šiem atbalstītajiem formātiem, taču šajā apmācībā es izmantošu .OBJ failu, kas lejupielādēts no Google Poly repozitorija.

Dodieties uz vietni Poly un lejupielādējiet aktīvu, kuru vēlaties izmantot .OBJ formātā (es izmantoju šo T-Rex modeli).

• Izņemiet mapi, kurā jābūt modeļa avota aktīvu failam (.OBJ, .FBX vai .glTF). Atkarībā no modeļa šajā mapē var būt arī dažas modeļa atkarības, piemēram, faili .mtl, .bin, .png vai .jpeg formātos.

3D modeļu importēšana Android Studio

Kad esat ieguvis savu īpašumu, tas jāimportē Android Studio, izmantojot Sceneform spraudni. Šis ir daudzpakāpju process, kura veikšanai nepieciešams:

• Izveidojiet mapi “sampledata”. Parauga dati ir jauns mapes tips projektēšanas laika parauga datiem, kas netiks iekļauti jūsu APK, bet būs pieejami Android Studio redaktorā.
• Velciet un nometiet oriģinālo .OBJ aktīvu failu mapē “sampledata”.
• Veiciet Sceneform importēšanu un konvertēšanu .OBJ failā, kas ģenerēs .sfa un .sfb failus.

Lai gan tas var šķist vienkāršāks, nevajag velciet un nometiet .OBJ failu tieši projekta direktorijā “res”, jo tas nevajadzīgi iekļaus modeli jūsu APK.

Android Studio projektos pēc noklusējuma nav mapes “datadata”, tāpēc jums tā būs jāizveido manuāli:

• Ar vadības taustiņu noklikšķiniet uz projekta mapes “app”.
• Atlasiet “Jauns> Paraugu datu direktorijs” un izveidojiet mapi ar nosaukumu “sampledata”.
• Dodieties uz iepriekš lejupielādētiem 3D modeļa failiem. Atrodiet avota aktīvu failu (.OBJ, .FBX vai .glTF) un pēc tam velciet un nometiet to “izlases datu” direktorijā.
• Pārbaudiet, vai jūsu modelim ir kādas atkarības (piemēram, faili .mtl, .bin, .png vai .jpeg formātā). Ja atrodat kādu no šiem failiem, velciet un nometiet tos mapē “sampledata”.
• Programmā Android Studio noklikšķiniet uz 3D modeļa avota faila (.OBJ, .FBX vai .glTF) un pēc tam atlasiet “Sceneform Asset importēšana”.

• Nākamajā logā tiek parādīta informācija par failiem, kurus Sceneform ģenerēs, ieskaitot to, kur iegūtais .sfa fails tiks saglabāts jūsu projektā; Es izmantošu “neapstrādātu” direktoriju.
• Kad esat apmierināts ar ievadīto informāciju, noklikšķiniet uz Pabeigt.

Šis importēšana jūsu projektā veic dažas izmaiņas. Ja atverat failu build.gradle, redzēsit, ka Sceneform spraudnis ir pievienots kā atkarība no projekta:

atkarības {classpath com.android.tools.build:gradle:3.5.0-alpha06 classpath com.google.ar.sceneform: spraudnis: 1.7.0 // PIEZĪME. Nenovietojiet šeit lietojumprogrammu atkarības; tie pieder // individuālā moduļa build.gradle failos //}}

Atveriet moduļa līmeņa build.gradle failu un jūs atradīsit jaunu ierakstu sceneform.asset () savam importētajam 3D modelim:

lietot spraudni: com.google.ar.sceneform.plugin // Importēšanas laikā norādītais “Source Asset Ceļš” // sceneform.asset (sampledata / dinosaur.obj, // Importēšanas laikā norādītais “Materiāla ceļš” // Noklusējums , // “.sfa izvades ceļš”, kuru norādījāt importēšanas laikā // sampledata / dinosaur.sfa, // “.sfb izvades ceļš”, kuru jūs norādījāt importēšanas laikā // src / main / aktīvi / dinozaurs)

Apskatot mapes “izlases dati” un “neapstrādātas”, redzēsit, ka tajās ir attiecīgi jauni .sfa un .sfb faili.

Jūs varat priekšskatīt .sfa failu jaunajā Android Studio Sceneform Viewer:

• Android Studio izvēlnes joslā atlasiet “Skatīt> Rīki Windows> Skatītājs”.
• Kreisās puses izvēlnē atlasiet .sfa failu. Jūsu 3D modelim tagad vajadzētu parādīties skatītāja logā.

Parādiet savu 3D modeli

Nākamais mūsu uzdevums ir izveidot AR sesiju, kas izprot apkārtni un ļauj lietotājam ievietot 3D modeļus paplašinātā ainā.

Tas liek mums rīkoties šādi:

1. Izveidojiet ArFragment dalībnieka mainīgo

ArFragment veic lielu daļu no AR sesijas izveidē iesaistītajiem smagiem spēkiem, tāpēc mēs atsauci uz šo fragmentu norādīsim visā MainActivity klasē.

Šajā fragmentā es izveidoju dalībnieka mainīgo ArFragment un pēc tam inicializēju to onCreate () metodē:

privāts ArFragment arCoreFragment; @Override aizsargāts tukšums onCreate (Bundle savedInstanceState) {super.onCreate (savedInstanceState); ... ... ...} setContentView (R.layout.activity_main); arCoreFragment = (ArFragment) // Atrodiet fragmentu, izmantojot fragmentu pārvaldnieku // getSupportFragmentManager (). findFragmentById (R.id.main_fragment);

2. Veidojiet modeli, kuru var remontēt

Tagad mums ir jāpārveido mūsu .sfb fails ModelRenderable, kas galu galā padarīs mūsu 3D objektu.

Šeit es izveidoju modeli, kuru var atjaunot no sava projekta res / raw / dinozaurs .sbb faila:

privāts ModelRenderable dinoRenderable; ... ... ... ModelRenderable.builder () .setSource (this, R.raw.dinosaur) .build () .thenAccept (rendering -> dinoRenderable = renderable) .exceptionly (throvable -> {Log.e ( TAG, "Nevar ielādēt kausējamu"); atgriešanās null;}); }

3. Atbildiet uz lietotāja ievadi

ArFragment ir iebūvēts atbalsts pieskārienu, vilkšanas, saspiešanas un vērpšanas žestiem.

Mūsu lietotnē lietotājs pievienos 3D modeli ARCore Plane, piešķirot šai lidmašīnai krānu.

Lai nodrošinātu šo funkcionalitāti, mums jāreģistrē atzvanīšana, kas tiek izsaukta ikreiz, kad tiek piespiesta lidmašīna:

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

4. Noenkurojiet modeli

Šajā solī mēs izgūsim ArSceneView un pievienosim to AnchorNode, kas darbosies kā Ainas vecāku mezgls.

ArSceneView ir atbildīgs par vairāku svarīgu ARCore uzdevumu izpildi, ieskaitot ierīces kameras attēlu atveidošanu un Sceneform UX animācijas parādīšanu, kas parāda, kā lietotājam vajadzētu turēt un pārvietot savu ierīci, lai sāktu AR pieredzi. ArSceneView izcels arī visas lidmašīnas, kuras tas atrod, un ir gatavs lietotājam izvietot 3D modeļus sižetā.

Komponentam ARSceneView ir pievienota aina, kas ir vecāku un bērnu datu struktūra, kurā ietverti visi mezgli, kas jāveido.

Mēs sāksim izveidot AnchorNode tipa mezglu, kas darbosies kā mūsu ArSceneView vecāku mezgls.

Visi enkura mezgli paliek vienā un tajā pašā reālās pasaules pozīcijā, tāpēc, izveidojot enkura mezglu, mēs nodrošinām, ka mūsu 3D modeļi paliks fiksēti savā vietā paplašinātajā ainā.

Izveidosim mūsu enkura mezglu:

AnchorNode anchorNode = jauns AnchorNode (enkurs);

Pēc tam mēs varam izgūt ArSceneView, izmantojot getArSceneView (), un pievienot to AnchorNode:

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

5. Pievienojiet atbalstu pārvietošanai, mērogošanai un pagriešanai

Tālāk es izveidošu mezglu, kura tips ir TransformableNode. TransformableNode ir atbildīgs par mezglu pārvietošanu, mērogošanu un pagriešanu, pamatojoties uz lietotāja žestiem.

Kad esat izveidojis TransformableNode, varat to pievienot Renderable, kas modelim sniegs iespēju mērogot un pārvietot, pamatojoties uz lietotāja mijiedarbību. Visbeidzot, jums ir jāpieslēdz TransformableNode ar AnchorNode bērna un vecāka attiecībās, kas nodrošina TransformableNode un Pieliekamais paliek fiksēts savā vietā paplašinātajā ainā.

TransformableNode transformableNode = jauns TransformableNode (arCoreFragment.getTransformationSystem ()); // Pievienojiet transformableNode ar anchorNode // transformableNode.setParent (anchorNode); transformējamsNode.setRenderable (dinoRenderable); // Atlasiet mezglu // transformableNode.select (); }); }

Pabeigtā MainActivity

Pēc visu iepriekš minēto darbību veikšanas MainActivity vajadzētu izskatīties apmēram šādi:

importēt android.app.Aktivitāte; importēt android.app.ActivityManager; importēt androidx.appcompat.app.AppCompatActivity; importa android.content.Context; importēt android.net.Uri; importa android.os.Build; importēt android.os.Build.VERSION_CODES; importa android.os.Bundle; importa android.util.Log; importa android.view.MotionEvent; importa androidx.annotation.PieprasītApi; importēt com.google.ar.core.Anchor; importēt com.google.ar.core.HitResult; importēt com.google.ar.core.Plane; importēt com.google.ar.sceneform.AnchorNode; importēt com.google.ar.sceneform.rendering.ModelRenderable; importēt com.google.ar.sceneform.ux.ArFragment; importēt com.google.ar.sceneform.ux.TransformableNode; publiskās klases MainActivity paplašina AppCompatActivity {privāto statisko galīgo virkni TAG = MainActivity.class.getSimpleName (); privāts statiskā gala dubultā MIN_OPENGL_VERSION = 3.0; // Izveidojiet dalībnieka mainīgo modelim ModelRenderable // privātu ModelRenderable dinoRenderable; // ArFragment locekļa mainīgā izveidošana // privāts ArFragment arCoreFragment; @RequiresApi (api = VERSION_CODES.N) @Atvērt aizsargātu tukšumu onCreate (Bundle savedInstanceState) {super.onCreate (savedInstanceState); if (! checkDevice ((this)))) {atgriezties; } setContentView (R.layout.activity_main); arCoreFragment = (ArFragment) // Atrodiet fragmentu, izmantojot fragmentu pārvaldnieku // getSupportFragmentManager (). findFragmentById (R.id.main_fragment); if (Build.VERSION.SDK_INT> = VERSION_CODES.N) {// Veidojiet ModelRenderable // ModelRenderable.builder () .setSource (this, R.raw.dinosaur) .build () .thenAccept (renvable -> dinoRenderable = renderable) ) .izņēmuma kārtā (// Ja rodas kļūda ... // izmetama -> {//...tad Logcat // Log.e izdrukājiet sekojošo: (TAG, "Nevar ielādēt kausējamo"); atgriešanās null;} ); } // Klausieties onTap notikumus // arCoreFragment.setOnTapArPlaneListener ((HitResult hitResult, Plane plane, MotionEvent motionEvent) -> {if (dinoRenderable == null) {return;} Anchor enchor = hitResult.createAnchor (); // Build a tipa mezgls AnchorNode // AnchorNode anchorNode = new AnchorNode (enkurs); // Pievienojiet AnchorNode ar ainu // anchorNode.setParent (arCoreFragment.getArSceneView (). getScene ()); // Veidojiet TransformableNode tipa mezglu. TransformableNode transformableNode = jauns TransformableNode (arCoreFragment.getTransformationSystem ()); // Pievienojiet TransformableNode ar AnchorNode // transformableNode.setParent (anchorNode); // Pievienojiet Renderable // transformableNode.setRenderable (dinoRenderable); / transformableNode.select ();}); } publiska statiskā Būla checkDevice (galīgā darbības aktivitāte) {// Ja ierīcē darbojas operētājsistēma Android Marshmallow vai vecāka versija ... // if (Build.VERSION.SDK_INT <VERSION_CODES.N) {//...tad izdrukājiet šo uz Logcat // Log.e (TAG, "Sceneform nepieciešama Android N vai jaunāka"); aktivitāte.pabeigt (); atgriezties nepatiess; } Virkne openGlVersionString = (((ActivityManager) activity.getSystemService (Context.ACTIVITY_SERVICE)) .getDeviceConfigurationInfo () // Pārbaudiet OpenGL ES versiju // .getGlEsVersion (); // Ja ierīcē darbojas kas mazāks par OpenGL ES 3.0 ... // ja (Double.parseDouble (openGlVersionString) <MIN_OPENGL_VERSION) {//...tad Logcat izdrukājiet šādus datus: Log Log (TAG, " Nepieciešama OpenGL ES 3.0 vai jaunāka "); aktivitāte.pabeigt (); atgriezties nepatiess; } atgriezties patiess; }}

Pabeigtu projektu var lejupielādēt no GitHub.

Pārbaudiet savu Google ARCore paplašinātās realitātes lietotni

Tagad jūs esat gatavs pārbaudīt savu lietojumprogrammu fiziskā, atbalstītā Android ierīcē. Ja jums nepieder ierīce, kas atbalsta ARCore, savu AR lietotni var pārbaudīt Android emulatorā (ar nelielu papildu konfigurāciju, par kuru mēs runāsim nākamajā sadaļā).

Lai pārbaudītu savu projektu uz fiziskā Android ierīce:

• Instalējiet lietojumprogrammu mērķa ierīcē.
• Pēc pieprasījuma piešķiriet lietojumprogrammai piekļuvi ierīces kamerai.
• Ja jums tiek piedāvāts instalēt vai atjaunināt ARCore lietotni, pieskarieties “Turpināt” un pēc tam pabeidziet dialogu, lai pārliecinātos, vai izmantojat jaunāko un labāko ARCore versiju.
• Tagad jums vajadzētu redzēt kameras skatu kopā ar ierīces, kurā atrodas ierīce, animāciju. Pavērsiet kameru uz līdzenas virsmas un pārvietojiet ierīci apļveida kustībā, kā to parāda animācija. Pēc dažiem mirkļiem vajadzētu parādīties punktu sērija, kas norāda, ka ir noteikta plakne.

• Kad esat apmierināts ar šo punktu atrašanās vietu, pieskarieties tiem - jūsu 3D modelim tagad vajadzētu parādīties jūsu izvēlētajā plaknē!

• Mēģiniet fiziski pārvietoties pa modeli; atkarībā no jūsu apkārtnes, iespējams, varēsit veikt visus 360 grādus ap to. Jums arī jāpārbauda, ​​vai objekts met ēnu, kas atbilst reālās pasaules gaismas avotiem.

ARCore testēšana Android virtuālajā ierīcē

Lai pārbaudītu savas ARCore lietotnes Android virtuālajā ierīcē (AVD), jums būs nepieciešama Android emulatora versija 27.2.9 vai jaunāka. Jums jābūt pierakstītam arī AVD Google Play veikalā un jābūt iespējotam OpenGL ES 3.0 vai jaunākam.

Lai pārbaudītu, vai AVD pašlaik ir iespējota OpenGL ES 3.0 vai jaunāka versija:

• Palaidiet AVD, kā parasti.
• Atveriet jaunu termināļa logu (Mac) vai komandu uzvedni (Windows).
• Mainiet direktoriju (“cd”), lai terminālis / komandu uzvedne norāda jūsu Android SDK programmas “adb” atrašanās vietu, piemēram, mana komanda izskatās šādi:

Cd / Lietotāji / jessicathornsby / Bibliotēka / Android / sdk / platformas rīki

• Nospiediet tastatūras taustiņu Enter.
• Nokopējiet / ielīmējiet nākamo komandu terminālī un pēc tam nospiediet taustiņu “Enter”:

./adb logcat | grep eglMakeCurrent

Ja terminālis atgriež “ver 3 0” vai augstāku, tad OpenGL ES ir pareizi konfigurēts. Ja terminālis vai komandu uzvedne parāda kaut ko agrāk par 3.0, jums būs jāiespējo OpenGL ES 3.0:

• Pārslēdzieties atpakaļ uz savu AVD.
• Atrodiet pogas “Paplašinātā vadība”, kas peld līdzās Android emulatoram, un pēc tam atlasiet “Iestatījumi> Papildu”.
• Pārejiet uz sadaļu “OpenGL ES API līmenis> Maksimālais renderētāja līmenis (līdz OpenGL ES 3.1).”
• Restartējiet emulatoru.

Termināļa / komandu uzvednes logā nokopējiet / ielīmējiet šo komandu un pēc tam nospiediet taustiņu “Enter”.

./adb logcat | grep eglMakeCurrent

Tagad jums vajadzētu iegūt “ver 3 0” vai augstāku rezultātu, kas nozīmē, ka OpenGL ES ir pareizi konfigurēts.

Visbeidzot, pārliecinieties, vai jūsu AVD darbojas visjaunākā ARCore versija:

• Dodieties uz ARCore GitHub lapu un lejupielādējiet emulatoram jaunāko ARCore izlaidumu. Piemēram, rakstīšanas laikā jaunākais izlaidums bija “ARCore_1.7.0.x86_for_emulator.apk”.
• Velciet un nometiet APK uz darbojas AVD.

Lai pārbaudītu savu projektu AVD, instalējiet lietojumprogrammu un pēc pieprasījuma piešķiriet tai piekļuvi AVD “kamerai”.

Tagad jums vajadzētu redzēt kameras skatu uz modelētu istabu. Lai pārbaudītu savu lietojumprogrammu, pārvietojieties pa šo virtuālo telpu, atrodiet simulētu līdzenu virsmu un noklikšķiniet, lai uz šīs virsmas novietotu modeli.

Virtuālo kameru var pārvietot pa virtuālo istabu, nospiežot un turot taustiņus “Opcija” (macOS) vai “Alt” (Linux vai Windows) un pēc tam izmantojot jebkuru no šiem īsinājumtaustiņiem:

• Pārvietojieties pa kreisi vai pa labi. Nospiediet A vai D.
• Pārvietojieties uz leju vai uz augšu. Nospiediet Q vai E.
• Virzieties uz priekšu vai atpakaļ. Nospiediet W vai S.

Varat arī “pārvietoties” pa virtuālo skatu, nospiežot “Opcija” vai “Alt” un pēc tam izmantojot peli. Sākumā tas var justies nedaudz neveikls, taču, praktizējot, jums jāspēj veiksmīgi izpētīt virtuālo telpu. Kad esat atradis simulētu plakni, noklikšķiniet uz baltajiem punktiem, lai novietotu 3D modeli uz šīs virsmas.

Iesaiņošana

Šajā rakstā mēs izveidojām vienkāršu papildinātās realitātes lietotni, izmantojot ARCore un spraudni Sceneform.

Ja jūs nolemjat izmantot Google ARCore savos projektos, tad noteikti dalieties ar savu darbu komentāros zemāk!