Innehåll

• Importerar 3D-modeller med Sceneform-plugin
• Installera plugin Sceneform
• Sceneform UX och Java 8: Uppdatera projektberoenden
• Begär behörigheter med ArFragment
• AR krävs eller valfritt?
• 1. AR krävs
• 2. AR Valfritt
• Lägg till ArFragment i din layout
• Nedladdning av 3D-modeller med Googles Poly
• Importerar 3D-modeller till Android Studio
• Visa din 3D-modell
• 1. Skapa en ArFragment-medlemvariabel
• 2. Bygg en ModelRenderable
• 3. Svara på användarens inmatning
• 4. Förankra din modell
• 5. Lägg till stöd för att flytta, skala och rotera
• Den slutförda MainActivity
• Testa din Google ARCore augmented reality-app
• Testa ARCore på en virtuell Android-enhet
• Avslutar

Importerar 3D-modeller med Sceneform-plugin

Vanligtvis kräver arbetet med 3D-modeller specialkunskaper, men med lanseringen av Sceneform-pluginet har Google gjort det möjligt att återge 3D-modeller med Java - och utan måste lära sig OpenGL.

Sceneform-pluginprogrammet ger ett API på hög nivå som du kan använda för att skapa Renderdables från standard Android-widgetar, former eller material eller från 3D-tillgångar, till exempel .OBJ- eller .FBX-filer.

I vårt projekt kommer vi att använda Sceneform-insticksprogrammet för att importera en .OBJ-fil till Android Studio. När du importerar en fil med Sceneform kommer detta plugin automatiskt:

• Konvertera tillgångsfilen till en .sfb-fil. Detta är ett runtime-optimerat Sceneform Binary-format (.sfb) som läggs till din APK och sedan laddas vid körning. Vi kommer att använda den här .sfb-filen för att skapa en Renderable, som består av nät, material och texturer, och kan placeras var som helst inom den förstärkta scenen.
• Generera en .sfa-fil. Detta är en tillgångsbeskrivningsfil, som är en textfil som innehåller en läsbar beskrivning av .sfb-filen. Beroende på modell kan du kanske ändra utseendet genom att redigera texten i .sfa-filen.

Tänk bara på att Sceneform-insticksprogrammet i skrivande stund fortfarande var i beta, så att du kan stöta på fel, fel eller annat konstigt beteende när du använder detta plugin.

Installera plugin Sceneform

Sceneform-insticksprogrammet kräver Android Studio 3.1 eller högre. Om du är osäker på vilken version av Android Studio du använder väljer du "Android Studio> Om Android Studio" i verktygsfältet. Följande popup innehåller grundläggande information om din Android Studio-installation, inklusive dess versionnummer.

Så här installerar du plugin Sceneform:

• Om du är på en Mac väljer du "Android Studio> Inställningar ..." i verktygsfältet Android Studio och väljer sedan "Plugins" från vänster-menyn. Om du är på en Windows-dator väljer du "File> Settings> Plugins> Browse repositories."
• Sök efter "Sceneform." När "Google Sceneform Tools" visas väljer du "Installera."
• Starta om Android Studio när du uppmanas så att din plugin är redo att användas.

Sceneform UX och Java 8: Uppdatera projektberoenden

Låt oss börja med att lägga till beroenden vi kommer att använda i hela detta projekt. Öppna din build.gradle-fil på modulnivå och lägg till Sceneform UX-biblioteket, som innehåller ArFragment som vi kommer att använda i vår layout:

beroenden {implementeringsfilTree (dir: libs, inkluderar:) implementering androidx.appcompat: appcompat: 1.0.2 implementering 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 tillhandahåller UX-resurser, inklusive ArFragment // implementering "com.google.ar.sceneform.ux: sceneform-ux: 1.7.0" implementering "com. android.support:appcompat-v7:28.0.0 "}

Sceneform använder språkkonstruktioner från Java 8, så vi behöver också uppdatera vårt projekt Källkompatibilitet och målkompatibilitet till Java 8:

compileOptions {sourceCompatibility JavaVersion.VERSION_1_8 targetCompatibility JavaVersion.VERSION_1_8}

Slutligen måste vi använda Sceneform-plugin:

applicera plugin: com.google.ar.sceneform.plugin

Din färdigbyggda build.gradle-fil ska se ut så här:

applicera 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.ApsVideoSupportVilja_Conversion 28 JavaVersion.VERSION_1_8} buildTypes {release {minifyEnabled false proguardFiles getDefaultProguardFile (proguard-android-optimize.txt), proguard-rules.pro}}} beroenden {implementeringsfilTree (dir: libs, inkluderar:) implementering androidx.appcompat: appcompat: 1.0 .2 implementering 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 implementering "com.google. ar.sceneform.ux: sceneform-ux: 1.7.0 "implementering" com.android.support:appcompat-v7:28.0.0 "} applicera plugin: com.google.ar .sceneform.plugin

Begär behörigheter med ArFragment

Vår applikation kommer att använda enhetens kamera för att analysera dess omgivningar och placera 3D-modeller i den verkliga världen. Innan vår ansökan kan komma åt kameran kräver den kameratillstånd, så öppna projektets manifest och lägg till följande:

Android 6.0 gav användarna möjlighet att bevilja, neka och återkalla behörigheter på tillstånd-med-tillstånd-basis. Även om detta förbättrade användarupplevelsen måste Android-utvecklare nu manuellt begära behörigheter vid körning och hantera användarens svar. Den goda nyheten är att när man arbetar med Google ARCore implementeras processen för att begära kameratillstånd och hantera användarens svar automatiskt.

ArFragment-komponenten kontrollerar automatiskt om din app har kameratillstånd och begär den om det behövs innan AR-sessionen skapas. Eftersom vi kommer att använda ArFragment i vår app behöver vi inte skriva någon kod för att begära kameratillstånd.

AR krävs eller valfritt?

Det finns två typer av applikationer som använder AR-funktionalitet:

1. AR krävs

Om din ansökan är beroende av Google ARCore för att ge en bra användarupplevelse, måste du se till att den bara någonsin laddats ner till enheter som stöder ARCore. Om du markerar din app som "AR krävs" visas den bara i Google Play-butiken om enheten stöder ARCore.

Sedan vår ansökan gör kräver ARCore, öppna manifestet och lägg till följande:

Det finns också en chans att din applikation kan laddas ner till en enhet som stöder ARCore i teorin, men ARCore inte har installerat. När vi markerar vår app som "AR krävs" kommer Google Play automatiskt att ladda ner och installera ARCore tillsammans med din app, om den inte redan finns på målenheten.

Tänk bara på att även om din app är android: required = "true" kommer du att göra det fortfarande måste kontrollera att ARCore är närvarande vid körning, eftersom det finns en chans att användaren kan ha avinstallerat ARCore efter att ha laddat ner din app, eller att deras version av ARCore är inaktuell.

Den goda nyheten är att vi använder ArFragment, som automatiskt kontrollerar att ARCore är installerat och uppdaterat innan du skapar varje AR-session - så än en gång, detta är något vi inte behöver implementera manuellt.

2. AR Valfritt

Om din app innehåller AR-funktioner som är trevliga att ha men inte nödvändiga för att leverera dess kärnfunktioner kan du markera den här applikationen som "AR Valfritt." Din app kan sedan kontrollera om Google ARCore är närvarande vid körning och inaktivera dess AR-funktioner på enheter som inte stöder ARCore.

Om du skapar en "AR Valfri" -app, kommer ARCore att göra det inte installeras automatiskt tillsammans med din applikation, även om enheten har all hårdvara och mjukvara som krävs för att stödja ARCore. Din "AR Valfri" -app måste då kontrollera om ARCore är aktuell och aktuell och ladda ner den senaste versionen när och när det behövs.

Om ARCore inte är avgörande för din app kan du lägga till följande i ditt manifest:

Medan jag har öppet manifestet lägger jag också till Android: configChanges och android: screenOrientation, för att säkerställa att MainActivity hanterar orienteringsändringar graciöst.

Efter att ha lagt till allt detta till ditt manifest bör den färdiga filen se ut så här:

Lägg till ArFragment i din layout

Jag kommer att använda ARCores ArFragment, eftersom det automatiskt hanterar ett antal viktiga ARCore-uppgifter i början av varje AR-session. ArFragment kontrollerar särskilt att en kompatibel version av ARCore är installerad på enheten och att appen för närvarande har kameratillstånd.

När ArFragment har verifierat att enheten kan stödja din apps AR-funktioner skapar den en ArSceneView ARCore-session och appens AR-upplevelse är redo att gå!

Du kan lägga till ArFragment-fragmentet i en layoutfil, precis som ett vanligt Android Fragment, så öppna din Activity_main.xml-fil och lägg till en "com.google.ar.sceneform.ux.ArFragment" -komponent.

Nedladdning av 3D-modeller med Googles Poly

Det finns flera olika sätt att skapa Renderables, men i den här artikeln kommer vi att använda en 3D-tillgångsfil.

Sceneform stöder 3D-tillgångar i .OBJ, .glTF och .FBX-format, med eller utan animationer. Det finns gott om platser där du kan skaffa 3D-modeller i ett av dessa format som stöds, men i den här självstudien kommer jag att använda en .OBJ-fil, nedladdad från Googles Poly-arkiv.

Gå över till Poly-webbplatsen och ladda ner tillgången som du vill använda, i .OBJ-format (jag använder den här T-Rex-modellen).

• Packa upp mappen, som ska innehålla din modells källtillgångsfil (.OBJ, .FBX eller .glTF). Beroende på modell kan den här mappen också innehålla vissa modellberoende, till exempel filer i formatet .mtl, .bin, .png eller .jpeg.

Importerar 3D-modeller till Android Studio

När du har tillgången måste du importera den till Android Studio med Sceneform-insticksprogrammet. Detta är en process i flera steg som kräver att du:

• Skapa en "sampledata" -mapp. Sampledata är en ny mapptyp för samplingsdata för designtid som inte kommer att inkluderas i din APK, men kommer att finnas tillgängliga i Android Studio-redigeraren.
• Dra och släpp den ursprungliga .OBJ-tillgångsfilen till din "sampledata" -mapp.
• Utför Sceneform-import och konvertering på .OBJ-filen, som genererar .sfa- och .sfb-filerna.

Även om det kan verka mer enkelt, inte dra och släpp .OBJ-filen direkt i projektets "res" -katalog, eftersom detta kommer att orsaka att modellen onödigt inkluderas i din APK.

Android Studio-projekt innehåller inte en “sampledata” -mapp som standard, så du måste skapa en manuellt:

• Kontrollklicka på projektets “app” -mapp.
• Välj "Ny> Exempeldatakatalog" och skapa en mapp med namnet "sampledata."
• Navigera till de 3D-modellfiler som du laddat ner tidigare. Hitta källtillgångsfilen (.OBJ, .FBX eller .glTF) och dra och släpp den sedan i katalogen "sampledata".
• Kontrollera om din modell har beroenden (t.ex. filer i formatet .mtl, .bin, .png eller .jpeg). Om du hittar någon av dessa filer, dra och släpp dem i mappen "sampledata".
• I Android Studio, klicka-klicka på din 3D-modellkällfil (.OBJ, .FBX eller .glTF) och välj sedan "Importera scenformad tillgång."

• Följande fönster visar viss information om filerna som Sceneform kommer att generera, inklusive var den resulterande .sfa-filen kommer att lagras i ditt projekt; Jag kommer att använda den "råa" katalogen.
• När du är nöjd med den information du har angett klickar du på "Slutför."

Denna import gör några ändringar i ditt projekt. Om du öppnar din build.gradle-fil ser du att Sceneform-insticksprogrammet har lagts till som ett projektberoende:

beroenden {classpath com.android.tools.build:gradle:3.5.0-alpha06 classpath com.google.ar.sceneform: plugin: 1.7.0 // ANMÄRKNING: Placera inte dina applikationsberoenden här; de tillhör // i den enskilda modulen build.gradle-filer}}

Öppna din build.gradle-fil på modulnivå och du hittar en ny sceneform.asset () -post för din importerade 3D-modell:

applicera plugin: com.google.ar.sceneform.plugin // "Source Asset Path" som du angav under import // sceneform.asset (sampledata / dinosaur.obj, // "Material Path" du angav under import // Standard , // ".sfa Output Path" som du angav under import // sampledata / dinosaur.sfa, // ".sfb Output Path" som du angav under import // src / main / asset / dinosaur)

Om du tittar på mapparna "sampledata" och "rå" ser du att de innehåller nya .sfa- och .sfb-filer.

Du kan förhandsgranska .sfa-filen i Android Studios nya Sceneform Viewer:

• Välj "Visa> Verktyg Windows> Viewer" i menyraden för Android Studio.
• Välj din .sfa-fil i menyn till vänster. Din 3D-modell ska nu visas i visningsfönstret.

Visa din 3D-modell

Vår nästa uppgift är att skapa en AR-session som förstår omgivningen och gör att användaren kan placera 3D-modeller i en förstärkt scen.

Detta kräver att vi gör följande:

1. Skapa en ArFragment-medlemvariabel

ArFragment utför mycket av det tunga lyft som är involverat i att skapa en AR-session, så vi kommer att referera till detta fragment i vår MainActivity-klass.

I följande utdrag skapar jag en medlemsvariabel för ArFragment och initierar den sedan i metoden onCreate ():

privat arFragment arCoreFragment; @Override skyddat tomrum onCreate (Bundle SavedInstanceState) {super.onCreate (SavedInstanceState); ... ... ...} setContentView (R.layout.activity_main); arCoreFragment = (ArFragment) // Hitta fragmentet med fragmenthanteraren // getSupportFragmentManager (). findFragmentById (R.id.main_fragment);

2. Bygg en ModelRenderable

Vi måste nu förvandla vår .sfb-fil till en ModelRenderable, som så småningom kommer att göra vårt 3D-objekt.

Här skapar jag en ModelRenderable från mitt projekt res / raw / dinosaur .sfb-fil:

privat ModelRenderable dinoRenderable; ... ... ... ModelRenderable.builder () .setSource (detta, R.raw.dinosaur) .build () .thenAccept (renderable -> dinoRenderable = renderable) .exceptionellt (kastbart -> {Log.e ( TAG, "Kan inte ladda återgivningsbar"); return null;}); }

3. Svara på användarens inmatning

ArFragment har inbyggt stöd för tryck, dra, nypa och vrida gester.

I vår app kommer användaren att lägga till en 3D-modell till en ARCore-plan genom att ge det planet ett tryck.

För att kunna leverera den här funktionen måste vi registrera ett återuppringning som kommer att påkallas varje gång ett plan knackas:

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

4. Förankra din modell

I det här steget kommer vi att hämta en ArSceneView och fästa den till en AnchorNode, som kommer att fungera som scenens överordnade nod.

ArSceneView ansvarar för att utföra flera viktiga ARCore-uppgifter, inklusive rendering av enhetens kamerabilder, och visa en Sceneform UX-animation som visar hur användaren ska hålla och flytta sin enhet för att starta AR-upplevelsen. ArSceneView kommer också att markera alla plan som den upptäcker, redo för användaren att placera sina 3D-modeller inom scenen.

ARSceneView-komponenten har en Scene ansluten till den, som är en datorstruktur för förälder-barn som innehåller alla de noder som måste återges.

Vi kommer att börja med att skapa en nod av typen AnchorNode, som kommer att fungera som vår ArSceneViews modernod.

Alla förankringsnoder förblir i samma riktiga position, så genom att skapa en förankringsnod säkerställer vi att våra 3D-modeller förblir fixerade på plats i den förstärkta scenen.

Låt oss skapa vår förankringsnod:

AnchorNode anchorNode = new AnchorNode (anchor);

Vi kan sedan hämta en ArSceneView med getArSceneView () och fästa den till AnchorNode:

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

5. Lägg till stöd för att flytta, skala och rotera

Därefter kommer jag att skapa en nod av typen TransformableNode. TransformableNode är ansvarig för att flytta, skala och rotera noder, baserat på användares gester.

När du har skapat en TransformableNode kan du ansluta den Renderable, vilket ger modellen möjlighet att skala och flytta, baserat på användarinteraktion. Slutligen måste du ansluta TransformableNode till AnchorNode, i ett barn-förälderförhållande som säkerställer TransformableNode och Renderable förblir fast på plats inom den förstärkta scenen.

TransformableNode transformableNode = new TransformableNode (arCoreFragment.getTransformationSystem ()); // Anslut transformableNode till anchorNode // transformableNode.setParent (anchorNode); transformableNode.setRenderable (dinoRenderable); // Välj nod // transformableNode.select (); }); }

Den slutförda MainActivity

Efter att ha utfört alla ovanstående bör din MainActivity se ut så här:

import android.app.Aktivitet; 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; importera 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; importera com.google.ar.sceneform.ux.ArFragment; importera com.google.ar.sceneform.ux.TransformableNode; public class MainActivity utökar AppCompatActivity {privat statisk final String TAG = MainActivity.class.getSimpleName (); privat statisk slutlig dubbel MIN_OPENGL_VERSION = 3.0; // Skapa en medlemsvariabel för ModelRenderable // private ModelRenderable dinoRenderable; // Skapa en medlemsvariabel för ArFragment // privat ArFragment arCoreFragment; @RequiresApi (api = VERSION_CODES.N) @Override skyddat tomrum onCreate (Bundle SavedInstanceState) {super.onCreate (SavedInstanceState); if (! checkDevice ((detta))) {return; } setContentView (R.layout.activity_main); arCoreFragment = (ArFragment) // Hitta fragmentet med fragmenthanteraren // getSupportFragmentManager (). findFragmentById (R.id.main_fragment); if (Build.VERSION.SDK_INT> = VERSION_CODES.N) {// Build ModelRenderable // ModelRenderable.builder () .setSource (detta, R.raw.dinosaur) .build () .thenAccept (renderable -> dinoRenderable = renderable) ) .exceptionellt (// Om ett fel inträffar ... // kastbar -> {//...tryck sedan följande till Logcat // Log.e (TAG, "Kan inte ladda renderable"); return null;} ); } // Lyssna på onTap-händelser // arCoreFragment.setOnTapArPlaneListener ((HitResult hitResult, Plane plane, MotionEvent motionEvent) -> {if (dinoRenderable == null) {return;} Anchor anchor = hitResult.createAnchor (); // Build a nod av typ AnchorNode // AnchorNode anchorNode = new AnchorNode (anchor); // Anslut AnchorNode till Scene // anchorNode.setParent (arCoreFragment.getArSceneView (). getScene ()); // Bygg en nod av typen TransformableNode // TransformableNode transformableNode = new TransformableNode (arCoreFragment.getTransformationSystem ()); // Anslut TransformableNode till AnchorNode // transformableNode.setParent (anchorNode); // Anslut den Renderable // transformableNode.setRenderable (dinoRenderable); // Ställ in noden / / transformableNode.select ();}); } offentlig statisk boolesisk checkDevice (slutlig aktivitetsaktivitet) {// Om enheten kör Android Marshmallow eller tidigare ... // if (Build.VERSION.SDK_INT <VERSION_CODES.N) {//...stryk sedan följande till Logcat // Log.e (TAG, "Sceneform kräver Android N eller högre"); activity.finish (); returnera falskt; } String openGlVersionString = ((ActivityManager) aktivitet.getSystemService (Context.ACTIVITY_SERVICE)) .getDeviceConfigurationInfo () // Kontrollera versionen av OpenGL ES // .getGlEsVersion (); // Om enheten kör något mindre än OpenGL ES 3.0 ... // if (Double.parseDouble (openGlVersionString) <MIN_OPENGL_VERSION) {//...tryck sedan följande till Logcat // Log.e (TAG, " Kräver OpenGL ES 3.0 eller högre "); activity.finish (); returnera falskt; } returnera sant; }}

Du kan ladda ner det slutförda projektet från GitHub.

Testa din Google ARCore augmented reality-app

Du är nu redo att testa din ansökan på en fysisk, Android-enhet. Om du inte äger en enhet som stöder ARCore är det möjligt att testa din AR-app i Android Emulator (med lite extra konfiguration, som vi kommer att täcka i nästa avsnitt).

Att testa ditt projekt på en fysisk Android-enhet:

• Installera din applikation på målenheten.
• När du blir uppmanad, ge applikationen åtkomst till enhetens kamera.
• Om du uppmanas att installera eller uppdatera ARCore-appen trycker du på "Fortsätt" och slutför sedan dialogen för att se till att du kör den senaste och bästa versionen av ARCore.
• Du bör nu se en kameravy, komplett med en animering av en hand som håller en enhet. Rikta kameran mot en plan yta och flytta enheten i en cirkulär rörelse, vilket visas av animeringen. Efter några ögonblick bör en serie prickar dyka upp, vilket indikerar att ett plan har upptäckts.

• När du är nöjd med positionen för dessa punkter, ge dem ett tryck - din 3D-modell ska nu visas på ditt valda plan!

• Prova fysiskt att röra dig runt modellen. beroende på din omgivning kan du kanske göra hela 360 grader runt det. Du bör också kontrollera att objektet kastar en skugga som överensstämmer med verkliga ljuskällor.

Testa ARCore på en virtuell Android-enhet

För att testa dina ARCore-appar i en Android Virtual Device (AVD), behöver du Android Emulator version 27.2.9 eller senare. Du måste också vara inloggad i Google Play-butiken på din AVD och ha OpenGL ES 3.0 eller högre aktiverad.

För att kontrollera om OpenGL ES 3.0 eller högre för närvarande är aktiverat på din AVD:

• Starta din AVD, som normalt.
• Öppna ett nytt terminalfönster (Mac) eller en kommandotolken (Windows).
• Ändra katalog ("cd") så Terminal / Command Prompt pekar på platsen för din Android SDK: s "adb" -program, till exempel ser mitt kommando så här:

Cd / Användare / jessicathornsby / Library / Android / sdk / platform-tools

• Tryck på "Enter" på tangentbordet.
• Kopiera / klistra in nästa kommando i terminalen och tryck sedan på "Enter" -tangenten:

./adb logcat | grep eglMakeCurrent

Om terminalen returnerar “ver 3 0” eller högre, är OpenGL ES korrekt konfigurerad. Om terminalen eller kommandotolken visar något tidigare än 3.0, måste du aktivera OpenGL ES 3.0:

• Byt tillbaka till din AVD.
• Hitta remsan med "Utökad kontroll" -knappar som flyter längs med Android Emulator och välj sedan "Inställningar> Avancerad."
• Navigera till “OpenGL ES API-nivå> Renderer maximum (upp till OpenGL ES 3.1).”
• Starta om emulatorn.

I fönstret Terminal / Command Prompt, kopiera / klistra in följande kommando och tryck sedan på "Enter" -tangenten "

./adb logcat | grep eglMakeCurrent

Du bör nu få ett resultat av “ver 3 0” eller högre, vilket innebär att OpenGL ES är korrekt konfigurerad.

Slutligen, se till att din AVD kör den allra senaste versionen av ARCore:

• Gå över till ARCores GitHub-sida och ladda ner den senaste versionen av ARCore för emulatorn. Till exempel var den senaste versionen vid skrivandet "ARCore_1.7.0.x86_for_emulator.apk"
• Dra och släpp APK-enheten på ditt körande AVD.

För att testa ditt projekt på en AVD, installera din applikation och ge det åtkomst till AVD: s "kamera" när du uppmanas.

Du bör nu se en kameravy över ett simulerat rum. För att testa din applikation, rör dig runt det virtuella utrymmet, hitta en simulerad plan yta och klicka för att placera en modell på denna yta.

Du kan flytta den virtuella kameran runt det virtuella rummet genom att trycka och hålla ned "Alternativ" (macOS) eller "Alt" (Linux eller Windows) och sedan använda någon av följande kortkommandon:

• Flytta åt vänster eller höger. Tryck på A eller D.
• Flytta neråt eller uppåt. Tryck på Q eller E.
• Flytta framåt eller bakåt. Tryck på W eller S.

Du kan också "flytta" runt den virtuella scenen genom att trycka på "Alternativ" eller "Alt" och sedan använda musen. Detta kan känna sig lite klumpigt till en början, men med övning bör du kunna utforska det virtuella utrymmet. När du hittat ett simulerat plan klickar du på de vita prickarna för att placera din 3D-modell på denna yta.

Avslutar

I den här artikeln skapade vi en enkel augmented reality-app med ARCore och plugin Sceneform.

Om du bestämmer dig för att använda Google ARCore i dina egna projekt, var noga med att dela dina skapelser i kommentarerna nedan!