Poly API: Hämtar 3D-tillgångar för dina Android- och VR-appar

Innehåll

Visar 3D-tillgångar med Poly
Skapa ett 3D-modelleringsprojekt
Skapa ett Google Cloud Platform-konto
Skaffa din Poly API-nyckel
Projektberoende: förlängningar för bränsle, P3D och Kotlin
Lägga till din API-nyckel
Hämta tillgången
Skapa en andra skärm: Lägg till navigering
Bygga en 3D-duk
Ritning på P3Ds duk
Testa ditt projekt
Avslutar
Relaterad

Har du en bra idé för en mobilapp för Virtual Reality (VR) eller Augmented Reality (AR), men ingen aning om hur du kan leva din vision till liv?

Såvida du inte är en Android-utvecklare som också råkar vara en erfaren 3D-artist, kan det vara en skrämmande process att skapa alla tillgångar som krävs för att leverera en uppslukande 360-gradersupplevelse.

Bara för att du inte har tid, resurser eller erfarenhet som krävs för att skapa 3D-modeller, inte betyder att du inte kan bygga en fantastisk VR- eller AR-mobilapp! Det finns ett enormt utbud av 3D-resurser som är fritt tillgängliga på webben, plus alla API: er, ramar och bibliotek som du behöver för att ladda ner och återge dessa tillgångar i dina Android-applikationer.

Läs nästa: Du kan nu besöka valfri webbplats med Daydream VR. Till och med den.

I den här artikeln kommer vi att titta på Poly, ett online-arkiv och API som gör tusentals 3D-tillgångar till hands. I slutet av den här artikeln har du skapat en app som hämtar en 3D Poly-tillgång vid körning och sedan återger den med det populära Processing for Android-biblioteket.

Visar 3D-tillgångar med Poly

Om du någonsin har försökt utveckla Unity, så är Poly-arkivet liknande Unity Asset Store - förutom att allt i Poly är gratis!

Många av Polys 3D-modeller publiceras under Creative Commons-licensen, så du är fri att använda, modifiera och remixa dessa tillgångar, så länge du ger skaparen lämplig kredit.

Alla Polys 3D-modeller är utformade för att vara kompatibla med Googles VR- och AR-plattformar, till exempel Daydream och ARCore, men du kan använda dem varhelst du än vill - eventuellt kan du till och med använda dem med Apples ARKit!

När det gäller att hämta och visa Poly-tillgångar har du två alternativ. Först kan du ladda ner tillgångarna till din dator och sedan importera dem till Android Studio, så de skickar med din applikation och bidrar till dess APK-storlek, eller så kan du hämta dessa tillgångar under drift med Poly API.

Den tvärplattform, REST-baserade Poly API ger programmatisk, skrivskyddad åtkomst till Polys enorma samling av 3D-modeller. Detta är mer komplicerat än att samla tillgångar med din APK, men det finns flera fördelar med att hämta Poly-tillgångar under körning, särskilt att det hjälper till att hålla din APK-storlek under kontroll, vilket kan påverka hur många som laddar ner din applikation.

Du kan också använda Poly API för att ge dina användare mer val, till exempel om du utvecklar ett mobilspel kan du låta dina användare välja från en rad karaktärsmodeller.

Eftersom du är fri att modifiera Poly-modellerna, kan du till och med låta dina användare justera sin valda karaktär, till exempel genom att ändra hår eller ögonfärg, eller genom att kombinera den med andra Poly-tillgångar, till exempel olika vapen och rustningar. På detta sätt kan Poly API hjälpa dig att leverera ett imponerande utbud av 3D-tillgångar, med mycket utrymme för att anpassa upplevelsen - och allt för relativt lite arbete. Dina användare kommer att vara övertygade om att du har spenderat ett ton tid och noggrant utformat alla dessa 3D-modeller!

Skapa ett 3D-modelleringsprojekt

Vi kommer att skapa en applikation som hämtar en viss Poly-tillgång när applikationen först startas och sedan visar den tillgången i helskärmsläge, på användarens begäran.

För att hjälpa oss att hämta den här tillgången använder jag Fuel, som är ett HTTP-nätverksbibliotek för Kotlin och Android. Börja med att skapa ett nytt projekt med inställningarna du väljer, men när du uppmanas att välja "Inkludera Kotlin-support."

Alla samtal du ringer till Poly API måste innehålla en API-nyckel som används för att identifiera din app och verkställa användningsgränser. Under utveckling och testning använder du ofta en obegränsad API-nyckel, men om du har några planer på att släppa den här appen måste du använda en Android-begränsad API-nyckel.

För att skapa en begränsad nyckel måste du känna till projektets SHA-1-signeringscertifikat, så låt oss få den här informationen nu:

Välj fliken "Gradle" i Android Studio (där markören är placerad i följande skärmdump). Detta öppnar en "Gradle projects" -panel.

I panelen "Gradle projects" dubbelklickar du för att utöka projektets "root" och välj sedan "Tasks> Android> Signing Report." Detta öppnar en ny panel längst ner i fönstret Android Studio.
Välj knappen 'Växla exekveringar av uppgifter / textläge' (där markören är placerad i följande skärmdump).

Panelen "Kör" kommer nu att uppdateras för att visa mycket information om ditt projekt, inklusive SHA-1-fingeravtrycket.

Skapa ett Google Cloud Platform-konto

För att få den nödvändiga API-nyckeln behöver du ett Google Cloud Platform-konto (GPC) -konto.

Om du inte har ett konto kan du registrera dig för en tolvmånaders kostnadsfri testperiod genom att gå till Try Cloud Platform gratis sida och följa anvisningarna. Observera att ett kreditkort eller betalkort krävs, men enligt sidan Vanliga frågor ställs detta bara för att verifiera din identitet och "du kommer inte att debiteras eller debiteras under din kostnadsfria prövning."

Skaffa din Poly API-nyckel

När alla är registrerade kan du aktivera Poly API och skapa din nyckel:

Gå över till GCP-konsolen.
Välj den fodrade ikonen i det övre vänstra hörnet och välj "API: er & tjänster> Kontrollpanelen."
Välj "Aktivera API: er och tjänster."
I menyn till vänster väljer du "Övrigt".
Välj "Poly API" -kortet.
Klicka på knappen "Aktivera".
Efter några ögonblick kommer du till en ny skärm. öppna sidmenyn och välj "API: er & tjänster> Intyg."

I den efterföljande popupen väljer du "Begränsningsknapp."
Ge din nyckel ett distinkt namn.
Välj "Android-appar" under "Applikationsbegränsningar".
Välj "Lägg till paketnamn och fingeravtryck."
Kopiera / klistra in projektets SHA-1-fingeravtryck i fältet "Signing-Certificate fingerprint".
Ange projektets paketnamn (det visas i ditt manifest och högst upp i varje klassfil).
Klicka på "Spara".

Du kommer nu att tas till projektets "Credentials" -skärm, som innehåller en lista över alla dina API-nycklar - inklusive den Poly-aktiverade API-nyckeln som du just skapade.

Projektberoende: förlängningar för bränsle, P3D och Kotlin

För att hämta och visa Poly-tillgångar behöver vi en hjälpande hand från några ytterligare bibliotek:

Bränsle. Poly har för närvarande inte någon officiell Android-verktygssats, så du måste arbeta med API direkt med REST-gränssnittet. För att göra denna process enklare använder jag Fuel HTTP-nätverksbiblioteket.
Bearbetar för Android. Jag kommer att använda detta bibliotekets P3D-renderare för att visa Poly-tillgången.

Öppna projektets build.gradle-fil och lägg till dessa två bibliotek som projektberoende:

beroenden {implementeringsfilTree (inkludera:, dir: libs) implementering "org.jetbrains.kotlin: kotlin-stdlib-jre7: $ kotlin_version" implementering com.android.support:appcompat-v7:27.1.1 // Lägg till Fuel-biblioteket / / implementering com.github.kittinunf.fuel: fuel-android: 1.13.0 // Lägg till Processing for Android-motorn // implementering org.p5android: processor-core: 4.0.1}

För att göra vår kod mer kortfattad använder jag också Kotlin Android-tillägg, så låt oss lägga till detta plugin medan vi har build.gradle-filen öppen:

applicera plugin: kotlin-android-tillägg

Slutligen, eftersom vi hämtar tillgången från Internet, behöver vår app internettillstånd. Öppna ditt manifest och lägg till följande:

Lägga till din API-nyckel

Varje gång vår app begär en tillgång från Poly, måste den innehålla en giltig API-nyckel. Jag använder platshållare text, men du måste ersätt den här platshållaren med din egen API-nyckel om applikationen någonsin kommer att fungera.

Jag lägger också till en check, så att applikationen kommer att visa en varning om du glömmer att ersätta texten "INSERT-YOUR-API-KEY":

import android.os.Bundle import android.support.v7.app.AppCompatActivity class MainActivity: AppCompatActivity () {companion object {const val APIKey = "INSERT-YOUR-API-KEY"} åsidosätter kul påCreate (sparadInstanceState: Bundle?) { super.onCreate (sparadInstanceState) setContentView (R.layout.activity_main) // Om API-nyckeln börjar med "INSERT" ... // if (APIKey.startsWith ("INSERT")) {// visas sedan följande toast ... .// Toast.makeText (detta, "Du har inte uppdaterat din API-nyckel", Toast.LENGTH_SHORT) .show ()} annat {... ... ...

Hämta tillgången

Du kan välja vilken tillgång som helst på Google Poly-webbplatsen, men jag kommer att använda den här modellen av jorden.

Du hämtar en tillgång med dess ID, som visas i slutet av URL-sluggen (markerad i föregående skärmdump). Vi kombinerar detta tillgångs-ID med Poly API-värden, som är "https://poly.googleapis.com/v1."

Därefter måste vi göra en GET-förfrågan till tillgångsadressen med metoden httpGet (). Jag anger också att svarstypen måste vara JSON:

Tillgången kan ha flera format, såsom OBJ, GLTF och FBX. Vi måste fastställa att tillgången är i OBJ-format.

I det här steget hämtar jag också namn och URL på alla filer vi behöver ladda ner,
inklusive tillgångens primära fil ("root"), plus alla tillhörande material- och texturfiler ("resurser").

Om vår applikation inte kan hämta tillgången korrekt visar den en skål som informerar användaren.

import android.content.Intent import android.os.Bundle import android.support.v7.app.AppCompatActivity import android.widget.Toast import com.github.kittinunf.fuel.android.extension.responseJson import com.github.kittinunf.fuel .httpDownload import com.github.kittinunf.fuel.httpFå import kotlinx.android.synthetic.main.activity_main. * import java.io.File class MainActivity: AppCompatActivity () {companion object {const val APIKey = "INSERT-YOUR-API -KEY "val assetURL =" https://poly.googleapis.com/v1/assets/94XG1XUy10q "} åsidosätta kul onCreate (SavedInstanceState: Bundle?) {Super.onCreate (SavedInstanceState) setContentView (R.layout.activity_main) if ( APIKey.startsWith ("INSERT")) {Toast.makeText (detta, "Du har inte uppdaterat din API-nyckel", Toast.LENGTH_SHORT) .show ()} annat {// Gör en GET-förfrågan till tillgångsadressen // assetURL. httpGet (listOf ("nyckel" till APIKey)). responseJson {begäran, svaret, resultatet -> // Gör något med svaret // result.fold ({val asset = it.obj () var objectURL: String? = null var materialLibraryName: String? = null var materialLibraryURL: String? = null // Kontrollera tillgångsformat med hjälp av "format" -fältet // val assetFormats = asset.getJSONArray ("format") // Gå igenom alla format // för (i i 0 tills assetFormats.length ()) { val currentFormat = assetFormats.getJSONObject (i) // Använd formattyp för att identifiera denna resurs formattyp. Om formatet är OBJ… .// if (currentFormat.getString ("formatType") == "OBJ") {//...hämta resursens "root" -fil, dvs OBJ-filen // objectURL = currentFormat. getJSONObject ("root") .getString ("url") // Hämta alla rotfils beroenden // materialLibraryName = currentFormat.getJSONArray ("resurser") .getJSONObject (0) .getString ("relativePath") materialLibraryURL = currentFormat.getJSONAray ("resurser") .getJSONObject (0) .getString ("url") break}} objectURL !!. httpDownload (). destination {_, _ -> File (filesDir, "globeAsset.obj")} .response {_ , _, result -> result.fold ({}, {// Om du inte kan hitta eller ladda ner OBJ-filen, visa sedan ett fel // Toast.makeText (detta, "Kan inte ladda ner resurs", Toast.LENGTH_SHORT ) .show ()})} materialLibraryURL !!. httpDownload (). destination {_, _ -> File (filesDir, materialLibraryName)}. svar {_, _, result -> result.fold ({}, {Toast. makeText (detta, "Det går inte att ladda ner resurs", Toast.LENGTH_SHORT) .show ()})}}, { Toast.makeText (detta, "Det går inte att ladda ner resurs", Toast.LENGTH_SHORT) .show ()})}}}

För närvarande, om du installerar projektet på din Android-smartphone eller surfplatta eller Android Virtual Device (AVD), kommer tillgången att ladda ner framgångsrikt, men appen visar den inte faktiskt. Låt oss fixa det här nu!

Skapa en andra skärm: Lägg till navigering

Vi kommer att visa tillgången i helskärmsläge, så låt oss uppdatera filen main_activity.xml så att den innehåller en knapp som, när du trycker på, kommer att starta fullskärmsaktivitet.

Låt oss nu lägga till onClickListener i slutet av filen MainActivity.kt:

import android.content.Intent import android.os.Bundle import android.support.v7.app.AppCompatActivity import android.widget.Toast import com.github.kittinunf.fuel.android.extension.responseJson import com.github.kittinunf.fuel .httpDownload import com.github.kittinunf.fuel.httpFå import kotlinx.android.synthetic.main.activity_main. * import java.io.File class MainActivity: AppCompatActivity () {companion object {const val APIKey = "INSERT-YOUR-API -KEY "val assetURL =" https://poly.googleapis.com/v1/assets/94XG1XUy10q "} åsidosätta kul onCreate (SavedInstanceState: Bundle?) {Super.onCreate (SavedInstanceState) setContentView (R.layout.activity_main) if ( APIKey.startsWith ("INSERT")) {Toast.makeText (detta, "Du har inte uppdaterat din API-nyckel", Toast.LENGTH_SHORT) .show ()} annat {assetURL.httpGet (listOf ("nyckel" till APIKey)). responseJson {begäran, svar, resultat -> result.fold ({val asset = it.obj () var objectURL: String? = null var materialLibraryName: String? = null var materialLibraryURL: Str Ing? = null val assetFormats = asset.getJSONArray ("format") för (i i 0 tills assetFormats.length ()) {val currentFormat = assetFormats.getJSONObject (i) if (currentFormat.getString ("formatType") == "OBJ" ) {objectURL = currentFormat.getJSONObject ("root") .getString ("url") materialLibraryName = currentFormat.getJSONArray ("resources") .getJSONObject (0) .getString ("relativePath") materialLibraryURL = currentFormat.getJSONArray ) .getJSONObject (0) .getString ("url") break}} objectURL !!. httpDownload (). destination {_, _ -> File (filesDir, "globeAsset.obj")}. svar {_, _, resultat -> result.fold ({}, {Toast.makeText (detta, "Det går inte att ladda ner resurs", Toast.LENGTH_SHORT). show ()})} materialLibraryURL !!. httpDownload (). destination {_, _ -> File (filesDir, materialLibraryName)} .respons {_, _, result -> result.fold ({}, {Toast.makeText (detta, "Kan inte ladda ner resurs", Toast.LENGTH_SHORT). show ()})}}, {Toast.makeText (detta, "Det går inte att ladda ner resurs", Toast.LENGTH_SHORT) .sh ow ()})} // Implementera en knapp // displayButton.setOnClickListener {val intention = Intent (this, SecondActivity :: class.java) startActivity (intention); }}}

Bygga en 3D-duk

Låt oss nu skapa aktiviteten där vi kommer att visa vår tillgång i helskärmsläge:

Kontrollklicka på projektets MainActivity.kt-fil och välj "Ny> Kotlin-fil / klass."
Öppna rullgardinsmenyn "Kind" och välj "Class."
Ge denna klass namnet "SecondActivity" och klicka sedan på "OK."

För att rita ett 3D-objekt behöver vi en 3D-duk! Jag kommer att använda Processing for Android: s biblioteks P3D-återgivare, vilket innebär att utvidga PApplet-klassen, åsidosätta metoden inställningar () och sedan skicka P3D som ett argument till metoden fullScreen (). Vi måste också skapa en egenskap som representerar Poly-tillgången som ett PShape-objekt.

privat rolig displayAsset () {val canvas3D = objekt: PApplet () {var polyAsset: PShape? = null åsidosätter roliga inställningar () {fullScreen (PConstants.P3D)}

Därefter måste vi initiera PShape-objektet genom att åsidosätta metoden setup (), ringa metoden loadShape () och sedan passera den absoluta banan för .obj-filen:

åsidosätta kulinställningen () {polyAsset = loadShape (File (filesDir, "globeAsset.obj"). absolutePath)}

Ritning på P3Ds duk

För att rita på denna 3D-duk måste vi åsidosätta metoden Draw ():

åsidosätta roliga drag () {bakgrund (0) form (polyAsset)}}

Som standard är många av tillgångarna som hämtats från Poly API på den mindre sidan, så om du kör denna kod nu kanske du inte ens ser tillgången, beroende på din skärmkonfiguration. När du skapar 3D-scener skapar du vanligtvis en anpassad kamera så att användaren kan utforska scenen och se dina 3D-tillgångar från hela 360 grader. Detta är dock utanför artikelns räckvidd så jag kommer att ändra tillgångens storlek och position manuellt för att se till att den passar bekvämt på skärmen.

Du kan öka tillgångens storlek genom att överföra ett negativt värde till skalan () -metoden:

skala (-10f)

Du kan justera tillgångens position i det virtuella 3D-utrymmet med metoden translate () och följande koordinater:

X. Placerar tillgången längs den horisontella axeln.
Y. Placerar tillgången längs den vertikala axeln.
Z. Detta är "djup / höjd" -axeln, som omvandlar ett 2D-objekt till ett 3D-objekt. Positiva värden skapar intrycket av att objektet kommer mot dig och negativa värden skapar intrycket att objektet rör sig bort från dig.

Observera att transformationer är kumulativa, så allt som händer efter funktionen samlar effekten.

Jag använder följande:

översätta (-50f, -100f, 10f)

Här är den färdiga koden:

åsidosätta roliga drag () {bakgrund (0) skala (-10f) översätta (-50f, -100f) // Rita tillgången genom att kalla formen () -metoden // form (polyAsset)}}

Därefter måste vi skapa motsvarande layoutfil, där vi lägger till 3D-duken som en FrameLayout-widget:

Kontrollklicka på projektets "res> layout" -mapp.
Välj "Layoutresursfil."
Ge den här filen namnet "aktivitet_sekund" och klicka sedan på "OK."

Nu har vi vår "asset_view" FrameLayout, vi måste låta vår SecondActivity veta om det! Vänd tillbaka till filen SecondActivity.kt, skapa en ny PFragment-instans och peka den i riktningen för vår "asset_view"-widget:

importera android.os.Bundle import android.support.v7.app.AppCompatActivity importera kotlinx.android.synthetic.main.activity_second. * importbehandling.android.PFragmentimportbehandling.core.PApplet importbehandling.core.PConstants importbehandling.core .PShape import java.io.File class SecondActivity: AppCompatActivity () {åsidosätta fun onCreate (savedInstanceState: Bundle?) {Super.onCreate (sparedInstanceState) setContentView (R.layout.activity_second) displayAsset ()} privat fun displayAsset () {val canvas3D = objekt: PApplet () {var polyAsset: PShape? = null åsidosätta kulinställningar () {fullScreen (PConstants.P3D)} åsidosätta kulinställningen () {polyAsset = loadShape (File (filesDir, "globeAsset.obj"). absolutePath)} åsidosätta fun draw () {bakgrund (0) skala (-10f) översätta (-50f, -100f) form (polyAsset)}} // Lägg till följande // val assetView = PFragment (canvas3D) assetView.setView (asset_view, detta)}}

Det sista steget är att lägga till SecondActivity till ditt manifest:

// Lägg till följande //

Testa ditt projekt

Vi är nu redo att testa det färdiga projektet! Installera den på din Android-enhet eller AVD och se till att du har en aktiv Internet-anslutning. Så snart appen startar kommer den att ladda ner tillgången och du kan sedan se den genom att trycka på knappen "Visa tillgång".

Du kan ladda ner hela projektet från GitHub.

Avslutar

I den här artikeln tittade vi på hur man använder Poly API för att hämta en 3D-tillgång vid körning och hur man visar den tillgången med Processing for Android-biblioteket. Tror du att Poly API har potential att göra VR- och AR-utveckling tillgänglig för fler människor? Låt oss veta i kommentarerna nedan!

Relaterad

Google kommer att föra AR-appar till “hundratals miljoner” Android-enheter 2018
Google kommer att lära dig om AI och maskininlärning gratis
15 bästa VR-spel för Google Cardboard
10 bästa VR-appar för Google Cardboard
Vad är Google Fuchsia? Är detta den nya Android?
Vad är Google Duplex? - funktioner, släppningsdatum och mer
Hur man skapar en VR-app för Android på bara 7 minuter
Mobila VR-headset - vad är dina bästa alternativ?