Obsah

• Import 3D modelů pomocí pluginu Sceneform
• Instalace pluginu Sceneform
• Sceneform UX a Java 8: Aktualizace závislostí projektu
• Vyžádání oprávnění pomocí ArFragmentu
• AR Povinné nebo volitelné?
• 1. Požadováno AR
• 2. AR Volitelné
• Přidejte ArFragment do svého rozvržení
• Stahování 3D modelů pomocí služby Poly společnosti Google
• Import 3D modelů do Android Studio
• Zobrazte svůj 3D model
• 1. Vytvořte členskou proměnnou ArFragment
• 2. Vytvořte ModelRenderable
• 3. Reagujte na vstup uživatele
• 4. Ukotvte model
• 5. Přidejte podporu pro pohyb, změnu měřítka a rotaci
• Dokončená MainActivity
• Testování aplikace Google ARCore s rozšířenou realitou
• Testování ARCore na virtuálním zařízení Android
• Zabalení

Import 3D modelů pomocí pluginu Sceneform

Práce s 3D modely obvykle vyžaduje speciální znalosti, ale s vydáním pluginu Sceneform Google umožnila vykreslit 3D modely pomocí Java - a bez museli se učit OpenGL.

Plugin Sceneform poskytuje rozhraní API na vysoké úrovni, které můžete použít k vytváření Renderdables ze standardních widgetů, tvarů nebo materiálů pro Android nebo ze zdrojů 3D, jako jsou soubory .OBJ nebo .FBX.

V našem projektu použijeme plugin Sceneform k importu souboru .OBJ do Android Studio. Kdykoli importujete soubor pomocí aplikace Sceneform, tento plugin automaticky:

• Převeďte soubor podkladu na soubor .sfb. Toto je binární formát Sceneform Binary (.sfb) optimalizovaný za běhu, který se přidá do vašeho souboru APK a poté se načte za běhu. Tento soubor .sfb použijeme k vytvoření Renderable, který se skládá z mřížek, materiálů a textur a může být umístěn kdekoli v rozšířené scéně.
• Vygenerujte soubor .sfa. Toto je soubor s popisem díla, což je textový soubor obsahující popis souboru .sfb čitelný pro člověka. V závislosti na modelu bude pravděpodobně možné změnit jeho vzhled úpravou textu uvnitř souboru .sfa.

Nezapomeňte, že v době psaní byl plugin Sceneform stále v beta verzi, takže při používání tohoto pluginu můžete narazit na chyby, chyby nebo jiné podivné chování.

Instalace pluginu Sceneform

Plugin Sceneform vyžaduje Android Studio 3.1 nebo vyšší. Pokud si nejste jisti, kterou verzi aplikace Android Studio používáte, vyberte na panelu nástrojů možnost „Android Studio> O aplikaci Android Studio“. Následující vyskakovací okno obsahuje některé základní informace o instalaci aplikace Android Studio, včetně čísla verze.

Instalace pluginu Sceneform:

• Pokud používáte počítač Mac, vyberte na panelu nástrojů pro Android Studio „Android Studio> Předvolby ...“ a v nabídce vlevo vyberte „Pluginy“. Pokud používáte počítač se systémem Windows, vyberte možnost „Soubor> Nastavení> Pluginy> Procházet úložiště“.
• Vyhledejte „Sceneform.“ Když se zobrazí „Google Sceneform Tools“, vyberte „Install“.
• Po vyzvání restartujte Android Studio a váš plugin bude připraven k použití.

Sceneform UX a Java 8: Aktualizace závislostí projektu

Začněme tím, že přidáme závislosti, které budeme během tohoto projektu používat. Otevřete soubor build.gradle na úrovni modulu a přidejte knihovnu Sceneform UX, která obsahuje ArFragment, který použijeme v našem rozvržení:

závislosti {implementace fileTree (dir: libs, include:) implementace androidx.appcompat: appcompat: 1.0.2 implementace 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 poskytuje zdroje UX, včetně implementace ArFragmentu // com.google.ar.sceneform.ux: sceneform-ux: 1.7.0 „implementace“ com. android.support:appcompat-v7:28.0.0 "}

Sceneform používá jazykové konstrukty z Java 8, takže je také třeba aktualizovat zdrojovou kompatibilitu našeho projektu a kompatibilitu s cíli na Java 8:

compileOptions {sourceCompatibility JavaVersion.VERSION_1_8 targetKompatibilita JavaVersion.VERSION_1_8}

Nakonec musíme použít plugin Sceneform:

použít plugin: com.google.ar.sceneform.plugin

Váš dokončený soubor build.gradle by měl vypadat asi takto:

použít 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.AndroidJUnitRpatner"} sourceVýběr_komponenta_komponenta_komponenta_komponenta_komponenta_komponenta_komponenta_komponenta_komponenta_komponenta_komponenta_komponenta_komponenta_komponenta_komponenta_komponenta_komponenta_komponenta_komponenta_komponenta_komponenta_komponenta_komunikace. JavaVersion.VERSION_1_8} buildTypes {release {minifyEnabled false false proguardFiles getDefaultProguardFile (proguard-android-optimize.txt), proguard-rules.pro}}} závislosti {implementační souborTree (dir: libs, include:) implementace androidx.appcompat: appcompat: 1.0 .2 implementace 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 implementace "com.google. ar.sceneform.ux: sceneform-ux: 1.7.0 "implementace" com.android.support:appcompat-v7:28.0.0 "} použít plugin: com.google.ar .sceneform.plugin

Vyžádání oprávnění pomocí ArFragmentu

Naše aplikace použije kameru zařízení k analýze jejího okolí a umístění 3D modelů v reálném světě. Než bude mít naše aplikace přístup k fotoaparátu, vyžaduje povolení kamery, proto otevřete Manifest projektu a přidejte následující:

Android 6.0 umožnil uživatelům udělit, zamítnout a zrušit oprávnění na základě povolení podle oprávnění. I když to zlepšilo uživatelský dojem, vývojáři Androidu nyní musí za běhu vyžadovat ruční povolení a zpracovat odpověď uživatele. Dobrou zprávou je, že při práci s Google ARCore je implementován proces vyžádání povolení kamery a zpracování odpovědi uživatele automaticky.

Komponenta ArFragment automaticky před vytvořením relace AR zkontroluje, zda má vaše aplikace oprávnění k fotoaparátu, a poté ji v případě potřeby vyžádá. Protože v naší aplikaci budeme používat ArFragment, nemusíme psát žádný kód, abychom mohli požádat o povolení kamery.

AR Povinné nebo volitelné?

Existují dva typy aplikací, které používají funkci AR:

1. Požadováno AR

Pokud se vaše aplikace spoléhá na Google ARCore, aby byla zajištěna dobrá uživatelská zkušenost, musíte zajistit, aby byla vždy stažena pouze do zařízení, která podporují ARCore. Pokud označíte aplikaci jako „Vyžadováno AR“, zobrazí se v obchodě Google Play, pouze pokud zařízení podporuje ARCore.

Od naší aplikace ano vyžadují ARCore, otevřete Manifest a přidejte následující:

Existuje také možnost, že vaši aplikaci lze stáhnout do zařízení, které teoreticky podporuje ARCore, ale ve skutečnosti nemá ARCore nainstalován. Jakmile naši aplikaci označíme jako „Vyžadováno AR“, Google Play automaticky stáhne a nainstaluje ARCore spolu s vaší aplikací, pokud již není na cílovém zařízení přítomna.

Jen mějte na paměti, že i když je vaše aplikace Android: povinné = „true“, budete ještě pořád je třeba zkontrolovat, zda je program ARCore přítomen za běhu, protože existuje možnost, že uživatel mohl odinstalovat ARCore od stažení aplikace nebo že jeho verze ARCore je zastaralá.

Dobrou zprávou je, že používáme ArFragment, který před vytvořením automaticky zkontroluje, zda je ARCore nainstalován a aktuální, před vytvořením každý AR relace - takže ještě jednou nemusíme implementovat ručně.

2. AR Volitelné

Pokud vaše aplikace obsahuje funkce AR, které jsou pěkné, ale nejsou nezbytné pro zajištění její základní funkce, můžete tuto aplikaci označit jako „AR Optional.“ (Aplikace volitelné). Vaše aplikace pak může zkontrolovat, zda je Google ARCore přítomen za běhu, a deaktivovat její Funkce AR na zařízeních, která nepodporují ARCore.

Pokud vytvoříte aplikaci „AR Optional“, pak ARCore ano ne být automaticky nainstalován vedle vaší aplikace, i když má zařízení veškerý hardware a software potřebný pro podporu ARCore. Vaše aplikace „AR Optional“ bude muset zkontrolovat, zda je ARCore přítomná a aktuální, a stáhnout si nejnovější verzi podle potřeby.

Pokud ARCore není pro vaši aplikaci rozhodující, můžete do manifestu přidat následující:

Když mám otevřený Manifest, přidávám také android: configChanges a android: screenOrientation, aby se zajistilo, že MainActivity zvládne změny orientace elegantně.

Po přidání všeho do manifestu by měl dokončený soubor vypadat asi takto:

Přidejte ArFragment do svého rozvržení

Budu používat ArFragment ARCore, protože na začátku každé relace AR automaticky zpracovává řadu klíčových úkolů ARCore. ArFragment zejména zkontroluje, zda je v zařízení nainstalována kompatibilní verze ARCore a že aplikace aktuálně má povolení kamery.

Jakmile ArFragment ověří, že zařízení může podporovat funkce AR vaší aplikace, vytvoří relaci ArSceneView ARCore a aplikace AR je připravena k použití!

Fragment ArFragment můžete přidat do souboru rozvržení stejně jako běžný fragment Android, takže otevřete soubor activity_main.xml a přidejte komponentu „com.google.ar.sceneform.ux.ArFragment“.

Stahování 3D modelů pomocí služby Poly společnosti Google

Existuje několik různých způsobů, jak můžete vytvořit vykreslovací prvky, ale v tomto článku budeme používat 3D soubor podkladů.

Sceneform podporuje 3D podklady ve formátech .OBJ, .glTF a .FBX, s animacemi nebo bez nich. Existuje spousta míst, kde můžete získat 3D modely v jednom z těchto podporovaných formátů, ale v tomto tutoriálu budu používat soubor .OBJ stažený z úložiště Poly společnosti Google.

Přejděte na web Poly a stáhněte si dílo, které chcete použít, ve formátu .OBJ (používám tento model T-Rex).

• Rozbalte složku, která by měla obsahovat zdrojový soubor vašeho modelu (.OBJ, .FBX nebo .glTF). V závislosti na modelu může tato složka obsahovat také některé závislosti modelu, například soubory ve formátech .mtl, .bin, .png nebo .jpeg.

Import 3D modelů do Android Studio

Až budete mít své dílo, musíte jej importovat do Android Studio pomocí pluginu Sceneform. Jedná se o vícestupňový proces, který vyžaduje:

• Vytvořte složku „sampledata“. Sampledata je nový typ složky pro data vzorkovacího času, která nebudou zahrnuta do vašeho souboru APK, ale budou k dispozici v editoru Android Studio.
• Přetáhněte původní soubor .OBJ do své složky „sampledata“.
• Proveďte import a převod scény do souboru .OBJ, který vygeneruje soubory .sfa a .sfb.

Ačkoli se to může zdát jednodušší, ne přetáhněte soubor .OBJ přímo do adresáře „res“ vašeho projektu, protože to způsobí zbytečné zahrnutí modelu do souboru APK.

Projekty Android Studio ve výchozím nastavení neobsahují složku „sampledata“, takže ji budete muset vytvořit ručně:

• Control-klikněte na složku projektu 'app'.
• Vyberte „Nový> Sample Data Directory“ a vytvořte složku s názvem „sampledata“.
• Přejděte na soubory 3D modelu, které jste stáhli dříve. Vyhledejte zdrojový soubor aktiv (.OBJ, .FBX nebo .glTF) a poté jej přetáhněte do adresáře „sampledata“.
• Zkontrolujte, zda má váš model nějaké závislosti (například soubory ve formátu .mtl, .bin, .png nebo .jpeg). Pokud některý z těchto souborů najdete, přetáhněte je do složky „sampledata“.
• V Android Studiu klikněte na zdrojový soubor 3D modelu (.OBJ, .FBX nebo .glTF) a vyberte „Importovat scénář.“

• Následující okno zobrazuje některé informace o souborech, které program Sceneform vygeneruje, včetně toho, kde bude výsledný soubor .sfa uložen v projektu; Budu používat adresář „raw“.
• Až budete s zadanými informacemi spokojeni, klikněte na tlačítko Dokončit.

Tento import provede několik změn vašeho projektu. Pokud otevřete soubor build.gradle, uvidíte, že plugin Sceneform byl přidán jako závislost na projektu:

závislosti {classpath com.android.tools.build:gradle:3.5.0-alpha06 classpath com.google.ar.sceneform: plugin: 1.7.0 // POZNÁMKA: Nepokládejte zde závislost aplikací; patří // do jednotlivých souborů build.gradle souborů}}

Otevřete soubor build.gradle na úrovni modulu a pro importovaný 3D model najdete novou položku sceneform.asset ():

apply plugin: com.google.ar.sceneform.plugin // Cesta „Source Asset Path“, kterou jste zadali během importu // sceneform.asset (sampledata / dinosaur.obj, // „Cesta materiálu“, kterou jste zadali během importu // Výchozí , // Výstupní cesta „.sfa“, kterou jste zadali během importu // sampledata / dinosaur.sfa, // Výstupní cesta „.sfb“, kterou jste zadali během importu // src / main / asset / dinosaur)

Pokud se podíváte na složky „sampledata“ a „raw“, uvidíte, že obsahují nové soubory .sfa a .sfb.

V novém programu Sceneform Viewer pro Android Studio si můžete prohlédnout soubor .sfa:

• Na panelu nabídky Android Studio vyberte „Zobrazit> Nástroje Windows> Prohlížeč“.
• V nabídce vlevo vyberte soubor .sfa. Váš 3D model by se nyní měl objevit v okně prohlížeče.

Zobrazte svůj 3D model

Naším dalším úkolem je vytvoření relace AR, která rozumí jejímu okolí a umožňuje uživateli umisťovat 3D modely do rozšířené scény.

To vyžaduje, abychom udělali následující:

1. Vytvořte členskou proměnnou ArFragment

ArFragment provádí většinu náročných operací při vytváření relace AR, takže tento fragment budeme odkazovat v celé třídě MainActivity.

V následujícím fragmentu vytvářím členskou proměnnou pro ArFragment a poté ji inicializuji metodou onCreate ():

soukromý ArFragment arCoreFragment; @Override chráněné void onCreate (Bundle uloženéInstanceState) {super.onCreate (uloženéInstanceState); ... ... ...} setContentView (R.layout.activity_main); arCoreFragment = (ArFragment) // Najděte fragment pomocí správce fragmentů // getSupportFragmentManager (). findFragmentById (R.id.main_fragment);

2. Vytvořte ModelRenderable

Nyní musíme transformovat náš soubor .sfb do ModelRenderable, který nakonec vykreslí náš 3D objekt.

Tady vytvářím ModelRenderable ze souboru .sfb res / raw / dinosaur mého projektu:

soukromý modelRenderable dinoRenderable; ... ... ... ModelRenderable.builder () .setSource (this, R.raw.dinosaur) .build () .thenAccept (renderovatelné -> dinoRenderable = renderovatelné). Výjimečně (házitelné -> {Log.e ( TAG, „Nelze načíst vykreslovatelné“); návrat null;}); }

3. Reagujte na vstup uživatele

ArFragment má vestavěnou podporu pro gesta klepnutí, přetažení, štípnutí a kroucení.

V naší aplikaci uživatel přidá 3D model do roviny ARCore tím, že této rovině klepne.

Abychom tuto funkci dosáhli, musíme zaregistrovat zpětné volání, které se vyvolá při každém klepnutí na letadlo:

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

4. Ukotvte model

V tomto kroku se chystáme načíst ArSceneView a připojit jej k AnchorNode, který bude sloužit jako nadřazený uzel scény.

ArSceneView odpovídá za provádění několika důležitých úkolů ARCore, včetně vykreslování obrázků z fotoaparátu zařízení, a za zobrazení animace Sceneform UX, která ukazuje, jak by měl uživatel držet a přesouvat své zařízení, aby mohl začít s AR. ArSceneView také zvýrazní všechna letadla, která detekuje, připraven pro uživatele umisťovat své 3D modely do scény.

Komponenta ARSceneView je k ní připojena scéna, což je datová struktura typu nadřazený a podřízený obsahující všechny uzly, které je třeba vykreslit.

Začneme vytvořením uzlu typu AnchorNode, který bude fungovat jako nadřazený uzel našeho ArSceneView.

Všechny kotvící uzly zůstávají ve stejné reálné světové poloze, takže vytvořením kotvícího uzlu zajišťujeme, aby naše 3D modely zůstaly pevné na místě v rozšířené scéně.

Vytvořme náš kotevní uzel:

AnchorNode anchorNode = nový AnchorNode (kotva);

Potom můžeme načíst ArSceneView pomocí getArSceneView () a připojit jej k AnchorNode:

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

5. Přidejte podporu pro pohyb, změnu měřítka a rotaci

Dále vytvořím uzel typu TransformableNode. TransformableNode je zodpovědný za pohybující se, škálovatelné a rotující uzly na základě uživatelských gest.

Jakmile vytvoříte transformovatelný uzel, můžete jej připojit k vykreslení Renderable, což modelu umožní měnit měřítko a pohyb na základě interakce s uživatelem. Nakonec je třeba připojit TransformableNode k AnchorNode ve vztahu child-parent, který zajišťuje TransformableNode a Renderovatelné zůstávají pevné na místě v rozšířené scéně.

TransformableNode transformableNode = new TransformableNode (arCoreFragment.getTransformationSystem ()); // Připojte transformableNode k anchorNode // transformableNode.setParent (anchorNode); transformableNode.setRenderable (dinoRenderable); // Vyberte uzel // transformableNode.select (); }); }

Dokončená MainActivity

Po provedení výše uvedeného by měla vaše MainActivity vypadat asi takto:

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; importovat 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; public class MainActivity rozšiřuje AppCompatActivity {private static final String TAG = MainActivity.class.getSimpleName (); soukromé statické finále double MIN_OPENGL_VERSION = 3,0; // Vytvoření členské proměnné pro ModelRenderable // soukromé ModelRenderable dinoRenderable; // Vytvoření členské proměnné pro ArFragment // privátní ArFragment arCoreFragment; @RequiresApi (api = VERSION_CODES.N) @Override chráněné void onCreate (Bundle uloženéInstanceState) {super.onCreate (uloženéInstanceState); if (! checkDevice ((this))) {return; } setContentView (R.layout.activity_main); arCoreFragment = (ArFragment) // Najděte fragment pomocí správce fragmentů // getSupportFragmentManager (). findFragmentById (R.id.main_fragment); if (Build.VERSION.SDK_INT> = VERSION_CODES.N) {// Postavte ModelRenderable // ModelRenderable.builder () .setSource (this, R.raw.dinosaur) .build () .thenAccept (renderable -> dinoRenderable = renderable ). výjimečně (// Pokud dojde k chybě ... // hoditelné -> {//...enen vytiskněte následující do Logcat // Log.e (TAG, „Nelze načíst vykreslovatelné“); return null;} ); } // Poslouchejte události onTap // arCoreFragment.setOnTapArPlaneListener ((HitResult hitResult, Letadlo, MotionEvent motionEvent) -> {if (dinoRenderable == null) {return;} Anchor anchor = hitResult.createAnchor (); // Build a uzel typu AnchorNode // AnchorNode anchorNode = new AnchorNode (anchor); // Připojte AnchorNode ke scéně // anchorNode.setParent (arCoreFragment.getArSceneView (). getScene ()); // Vytvořte uzel typu TransformableNode // TransformableNode transformableNode = new TransformableNode (arCoreFragment.getTransformationSystem ()); // Připojte TransformableNode k AnchorNode // transformableNode.setParent (anchorNode); // Připojte Renderable // transformableNode.setRenderable (dinoRenderable); // Nastavte uzel / / transformableNode.select ();}); } veřejné statické boolean checkDevice (závěrečná aktivita) {// Pokud zařízení používá Android Marshmallow nebo starší ... // if (Build.VERSION.SDK_INT <VERSION_CODES.N) {//...tak vytiskněte následující Logcat // Log.e (TAG, „Scénář vyžaduje Android N nebo vyšší“); activity.finish (); návrat false; } String openGlVersionString = ((ActivityManager) activity.getSystemService (Context.ACTIVITY_SERVICE)) .getDeviceConfigurationInfo () // Zkontrolujte verzi OpenGL ES // .getGlEsVersion (); // Pokud zařízení běží něco méně než OpenGL ES 3.0 ... // if (Double.parseDouble (openGlVersionString) <MIN_OPENGL_VERSION) {//...tak vytiskněte následující do Logcat // Log.e (TAG, " Vyžaduje OpenGL ES 3.0 nebo vyšší "); activity.finish (); návrat false; } vrátit true; }}

Dokončený projekt si můžete stáhnout z GitHubu.

Testování aplikace Google ARCore s rozšířenou realitou

Nyní jste připraveni otestovat svou aplikaci na fyzickém podporovaném zařízení Android. Pokud nevlastníte zařízení, které podporuje ARCore, je možné otestovat vaši AR aplikaci v emulátoru Android (s trochou zvláštní konfigurace, kterou se věnujeme v další části).

Chcete-li otestovat svůj projekt na fyzický Zařízení Android:

• Nainstalujte aplikaci na cílové zařízení.
• Po zobrazení výzvy udělte aplikaci přístup k fotoaparátu vašeho zařízení.
• Pokud budete vyzváni k instalaci nebo aktualizaci aplikace ARCore, klepněte na „Pokračovat“ a poté dokončete dialog, abyste se ujistili, že používáte nejnovější a největší verzi ARCore.
• Nyní byste měli vidět pohled kamery, kompletní s animací ruky držící zařízení. Nasměrujte fotoaparát na rovnou plochu a pohybujte zařízením krouživým pohybem, jak ukazuje animace. Po několika okamžicích by se měla objevit řada teček, což znamená, že byla detekována rovina.

• Až budete s umístěním těchto bodů spokojeni, udělejte jim klepnutí - váš 3D model by se nyní měl objevit ve zvolené rovině!

• Zkuste fyzicky pohybovat kolem modelu; v závislosti na vašem okolí můžete být schopni kolem sebe dosáhnout celých 360 stupňů. Měli byste také zkontrolovat, zda objekt vrhá stín, který je v souladu se světelnými zdroji skutečného světa.

Testování ARCore na virtuálním zařízení Android

Chcete-li vyzkoušet své aplikace ARCore ve virtuálním zařízení Android (AVD), budete potřebovat Android Emulator verze 27.2.9 nebo vyšší. Musíte být také přihlášeni do obchodu Google Play na svém AVD a mít aktivovanou OpenGL ES 3.0 nebo vyšší.

Chcete-li zkontrolovat, zda je na vašem AVD aktuálně povoleno OpenGL ES 3.0 nebo vyšší:

• Spusťte AVD jako obvykle.
• Otevřete nové okno terminálu (Mac) nebo příkazový řádek (Windows).
• Změňte adresář („cd“) tak, aby terminál / příkazový řádek ukazoval na umístění programu „adb“ vašeho Android SDK, například můj příkaz vypadá takto:

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

• Stiskněte klávesu „Enter“ na klávesnici.
• Zkopírujte / vložte další příkaz do terminálu a stiskněte klávesu „Enter“:

./adb logcat | grep eglMakeCurrent

Pokud terminál vrátí „ver 3 0“ nebo vyšší, pak je OpenGL ES správně nakonfigurován. Pokud terminál nebo příkazový řádek zobrazí něco dříve než 3.0, musíte povolit OpenGL ES 3.0:

• Přepněte zpět na AVD.
• Najděte pruh tlačítek „Rozšířená kontrola“, která se vznášejí vedle emulátoru Android, a poté vyberte „Nastavení> Upřesnit“.
• Přejděte na „OpenGL ES API level> Maximum Renderer (až do OpenGL ES 3.1).“
• Restartujte emulátor.

V okně Terminál / Příkazový řádek zkopírujte / vložte následující příkaz a poté stiskněte klávesu „Enter“.

./adb logcat | grep eglMakeCurrent

Nyní byste měli získat výsledek „ver 3 0“ nebo vyšší, což znamená, že OpenGL ES je správně nakonfigurován.

Nakonec se ujistěte, že váš AVD používá nejnovější verzi ARCore:

• Přejděte na stránku GitHub společnosti ARCore a stáhněte si nejnovější verzi ARCore pro emulátor. Například v době psaní poslední verze byla „ARCore_1.7.0.x86_for_emulator.apk“
• Přetáhněte APK na váš běžící AVD.

Chcete-li otestovat svůj projekt na AVD, nainstalujte aplikaci a po zobrazení výzvy udělejte přístup k „kameře“ AVD.

Nyní byste měli vidět simulovanou místnost z pohledu kamery. Chcete-li otestovat svou aplikaci, pohybujte se po tomto virtuálním prostoru, najděte simulovanou rovnou plochu a kliknutím umístěte na tuto plochu model.

Virtuální kameru můžete pohybovat po virtuální místnosti stisknutím a podržením kláves „Option“ (macOS) nebo „Alt“ (Linux nebo Windows) a poté pomocí některého z následujících klávesových zkratek:

• Přesuňte doleva nebo doprava. Stiskněte tlačítko A nebo D.
• Posuňte dolů nebo nahoru. Stiskněte klávesu Q nebo E.
• Pohyb vpřed nebo vzad. Stiskněte klávesu W nebo S.

Můžete se také „pohybovat“ po virtuální scéně stisknutím „Option“ nebo „Alt“ a poté pomocí myši. To se může zpočátku cítit trochu neohrabaně, ale s praxí byste měli být schopni úspěšně prozkoumat virtuální prostor. Jakmile najdete simulovanou rovinu, kliknutím na bílé tečky umístěte svůj 3D model na tuto plochu.

Zabalení

V tomto článku jsme vytvořili jednoduchou aplikaci s rozšířenou realitou pomocí ARCore a pluginu Sceneform.

Pokud se rozhodnete používat Google ARCore ve svých vlastních projektech, nezapomeňte své výtvory sdílet v komentářích níže!