Cree una aplicación de Android de realidad aumentada con Google ARCore

Contenido

Importación de modelos 3D, con el complemento Sceneform
Instalación del complemento Sceneform
Sceneform UX y Java 8: Actualización de las dependencias de su proyecto
Solicitud de permisos con ArFragment
¿AR requerido u opcional?
1. AR requerido
2. AR opcional
Agregue ArFragment a su diseño
Descarga de modelos 3D, usando Poly de Google
Importar modelos 3D a Android Studio
Muestra tu modelo 3D
1. Crear una variable miembro ArFragment
2. Construir un modelo Renderable
3. Responder a la entrada del usuario
4. Ancla tu modelo
5. Agregue soporte para mover, escalar y rotar
La actividad principal completada
Probar su aplicación de realidad aumentada Google ARCore
Prueba de ARCore en un dispositivo virtual Android
Terminando

Importación de modelos 3D, con el complemento Sceneform

Por lo general, trabajar con modelos 3D requiere conocimientos especializados, pero con el lanzamiento del complemento Sceneform, Google ha hecho posible renderizar modelos 3D usando Java, y sin tener que aprender OpenGL.

El complemento Sceneform proporciona una API de alto nivel que puede usar para crear Renderdables a partir de widgets, formas o materiales estándar de Android, o de activos 3D, como archivos .OBJ o .FBX.

En nuestro proyecto, utilizaremos el complemento Sceneform para importar un archivo .OBJ a Android Studio. Cada vez que importe un archivo usando Sceneform, este complemento automáticamente:

Convierta el archivo de activos en un archivo .sfb. Este es un formato binario de forma de escena optimizado en tiempo de ejecución (.sfb) que se agrega a su APK y luego se carga en tiempo de ejecución. Utilizaremos este archivo .sfb para crear un Renderable, que consta de mallas, materiales y texturas, y se puede colocar en cualquier lugar dentro de la escena aumentada.
Genere un archivo .sfa. Este es un archivo de descripción de activos, que es un archivo de texto que contiene una descripción legible por humanos del archivo .sfb. Dependiendo del modelo, puede cambiar su apariencia editando el texto dentro del archivo .sfa.

Solo tenga en cuenta que en el momento de la escritura, el complemento Sceneform todavía estaba en versión beta, por lo que puede encontrar errores, errores u otro comportamiento extraño al usar este complemento.

Instalación del complemento Sceneform

El complemento Sceneform requiere Android Studio 3.1 o superior. Si no está seguro de qué versión de Android Studio está utilizando, seleccione "Android Studio> Acerca de Android Studio" en la barra de herramientas. La ventana emergente posterior contiene información básica sobre su instalación de Android Studio, incluido su número de versión.

Para instalar el complemento Sceneform:

Si está en una Mac, seleccione "Android Studio> Preferencias ..." en la barra de herramientas de Android Studio, luego elija "Complementos" en el menú de la izquierda. Si estás en una PC con Windows, selecciona "Archivo> Configuración> Complementos> Buscar repositorios".
Busque “Sceneform”. Cuando aparezca “Google Sceneform Tools”, seleccione “Instalar”.
Reinicie Android Studio cuando se le solicite, y su complemento estará listo para usar.

Sceneform UX y Java 8: Actualización de las dependencias de su proyecto

Comencemos agregando las dependencias que utilizaremos a lo largo de este proyecto. Abra el archivo build.gradle a nivel de módulo y agregue la biblioteca Sceneform UX, que contiene el ArFragment que usaremos en nuestro diseño:

dependencias {implementación fileTree (dir: libs, include:) implementación androidx.appcompat: appcompat: 1.0.2 implementación androidx.constraintlayout: restrictintlayout: 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 proporciona recursos UX, incluyendo ArFragment // implementación "com.google.ar.sceneform.ux: sceneform-ux: 1.7.0" implementación "com. android.support:appcompat-v7:28.0.0 "}

Sceneform utiliza construcciones de lenguaje de Java 8, por lo que también tendremos que actualizar la compatibilidad de origen y la compatibilidad de destino de nuestro proyecto con Java 8:

compileOptions {sourceCompatibility JavaVersion.VERSION_1_8 targetCompatibility JavaVersion.VERSION_1_8}

Finalmente, necesitamos aplicar el complemento Sceneform:

aplicar el complemento: com.google.ar.sceneform.plugin

El archivo build.gradle completado debería verse así:

application 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.AndroidnerUnitio de la empresa. JavaVersion.VERSION_1_8} buildTypes {release {minifyEnabled false proguardFiles getDefaultProguardFile (proguard-android-Optimize.txt), proguard-rules.pro}}} dependencias {implementación fileTree (dir: libs, include:) implementación androidx.appcompat: appcompat: 1.0 .2 implementación androidx.constraintlayout: restrictintlayout: 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 implementación "com.google. ar.sceneform.ux: sceneform-ux: 1.7.0 "implementación" com.android.support:appcompat-v7:28.0.0 "} aplica el complemento: com.google.ar .sceneform.plugin

Solicitud de permisos con ArFragment

Nuestra aplicación utilizará la cámara del dispositivo para analizar su entorno y posicionar modelos 3D en el mundo real. Antes de que nuestra aplicación pueda acceder a la cámara, requiere el permiso de la cámara, así que abra el Manifiesto de su proyecto y agregue lo siguiente:

Android 6.0 brindó a los usuarios la capacidad de otorgar, denegar y revocar permisos de forma autorizada. Si bien esto mejoró la experiencia del usuario, los desarrolladores de Android ahora deben solicitar permisos manualmente en tiempo de ejecución y manejar la respuesta del usuario. La buena noticia es que cuando se trabaja con Google ARCore, se implementa el proceso de solicitar el permiso de la cámara y manejar la respuesta del usuario automáticamente.

El componente ArFragment verifica automáticamente si su aplicación tiene el permiso de la cámara y luego lo solicita, si es necesario, antes de crear la sesión de AR. Como utilizaremos ArFragment en nuestra aplicación, no necesitamos escribir ningún código para solicitar el permiso de la cámara.

¿AR requerido u opcional?

Hay dos tipos de aplicaciones que usan la funcionalidad AR:

1. AR requerido

Si su aplicación se basa en Google ARCore para ofrecer una buena experiencia de usuario, entonces debe asegurarse de que solo se descargue en dispositivos compatibles con ARCore. Si marca su aplicación como "AR requerida", solo aparecerá en la tienda Google Play, si el dispositivo es compatible con ARCore.

Desde nuestra aplicación hace requiere ARCore, abra el Manifiesto y agregue lo siguiente:

También existe la posibilidad de que su aplicación se descargue a un dispositivo que sea compatible con ARCore en teoría, pero en realidad no tiene instalado ARCore. Una vez que marcamos nuestra aplicación como "AR requerida", Google Play descargará e instalará automáticamente ARCore junto con su aplicación, si aún no está presente en el dispositivo de destino.

Solo tenga en cuenta que incluso si su aplicación es android: required = "true", usted todavía necesita verificar que ARCore esté presente en tiempo de ejecución, ya que existe la posibilidad de que el usuario haya desinstalado ARCore desde la descarga de su aplicación, o que su versión de ARCore esté desactualizada.

La buena noticia es que estamos utilizando ArFragment, que verifica automáticamente que ARCore esté instalado y actualizado antes de crear cada Sesión AR: una vez más, esto es algo que no tenemos que implementar manualmente.

2. AR opcional

Si su aplicación incluye características de AR que son agradables pero no esenciales para ofrecer su funcionalidad principal, entonces puede marcar esta aplicación como "AR Opcional". Su aplicación puede verificar si Google ARCore está presente en el tiempo de ejecución y deshabilitar su Funciones de AR en dispositivos que no son compatibles con ARCore.

Si crea una aplicación "AR Opcional", ARCore lo hará no se instalará automáticamente junto con su aplicación, incluso si el dispositivo tiene todo el hardware y software necesarios para admitir ARCore. Su aplicación "AR Opcional" deberá verificar si ARCore está presente y actualizada, y descargar la última versión cuando sea necesario.

Si ARCore no es crucial para su aplicación, puede agregar lo siguiente a su Manifiesto:

Si bien tengo abierto el Manifiesto, también agrego android: configChanges y android: screenOrientation, para garantizar que MainActivity maneje los cambios de orientación con gracia.

Después de agregar todo esto a su Manifiesto, el archivo completo debería verse así:

Agregue ArFragment a su diseño

Usaré el ArFragment de ARCore, ya que maneja automáticamente una serie de tareas clave de ARCore al comienzo de cada sesión de AR. En particular, ArFragment comprueba que hay una versión compatible de ARCore instalada en el dispositivo y que la aplicación tiene actualmente el permiso de la cámara.

Una vez que ArFragment ha verificado que el dispositivo puede admitir las funciones AR de su aplicación, crea una sesión ArSceneView ARCore, ¡y la experiencia AR de su aplicación está lista para funcionar!

Puede agregar el fragmento ArFragment a un archivo de diseño, al igual que un Fragment de Android normal, así que abra su archivo activity_main.xml y agregue un componente “com.google.ar.sceneform.ux.ArFragment”.

Descarga de modelos 3D, usando Poly de Google

Hay varias formas diferentes de crear Renderables, pero en este artículo usaremos un archivo de activos 3D.

Sceneform admite recursos 3D en formatos .OBJ, .glTF y .FBX, con o sin animaciones. Hay muchos lugares donde puede adquirir modelos 3D en uno de estos formatos compatibles, pero en este tutorial utilizaré un archivo .OBJ, descargado del repositorio Poly de Google.

Dirígete al sitio web de Poly y descarga el activo que deseas usar, en formato .OBJ (estoy usando este modelo T-Rex).

Descomprima la carpeta, que debe contener el archivo de recursos fuente de su modelo (.OBJ, .FBX o .glTF). Dependiendo del modelo, esta carpeta también puede contener algunas dependencias del modelo, como archivos en los formatos .mtl, .bin, .png o .jpeg.

Importar modelos 3D a Android Studio

Una vez que tenga su activo, debe importarlo a Android Studio utilizando el complemento Sceneform. Este es un proceso de varios pasos que requiere que usted:

Cree una carpeta "sampledata". Sampledata es un nuevo tipo de carpeta para datos de muestra en tiempo de diseño que no se incluirán en su APK, pero estarán disponibles en el editor de Android Studio.
Arrastre y suelte el archivo de activos .OBJ original en su carpeta "sampledata".
Realice la importación y conversión de Sceneform en el archivo .OBJ, que generará los archivos .sfa y .sfb.

Aunque parezca más sencillo, no arrastre y suelte el archivo .OBJ directamente en el directorio "res" de su proyecto, ya que esto hará que el modelo se incluya innecesariamente en su APK.

Los proyectos de Android Studio no contienen una carpeta "sampledata" de forma predeterminada, por lo que deberá crear una manualmente:

Mantenga presionada la tecla Control y haga clic en la carpeta "aplicación" de su proyecto.
Seleccione "Nuevo> Directorio de datos de muestra" y cree una carpeta llamada "datos de muestra".
Navegue a los archivos de modelo 3D que descargó anteriormente. Busque el archivo de recursos fuente (.OBJ, .FBX o .glTF) y luego arrástrelo y suéltelo en el directorio "sampledata".
Compruebe si su modelo tiene dependencias (como archivos en los formatos .mtl, .bin, .png o .jpeg). Si encuentra alguno de estos archivos, arrástrelos y suéltelos en la carpeta "sampledata".
En Android Studio, presione Control y haga clic en el archivo fuente del modelo 3D (.OBJ, .FBX o .glTF) y luego seleccione "Importar activo de forma de escena".

La ventana siguiente muestra información sobre los archivos que Sceneform va a generar, incluido dónde se almacenará el archivo .sfa resultante en su proyecto; Voy a usar el directorio "en bruto".
Cuando esté satisfecho con la información que ingresó, haga clic en "Finalizar".

Esta importación realiza algunos cambios en su proyecto. Si abre su archivo build.gradle, verá que el complemento Sceneform se ha agregado como una dependencia del proyecto:

dependencias {classpath com.android.tools.build:gradle:3.5.0-alpha06 classpath com.google.ar.sceneform: plugin: 1.7.0 // NOTA: No coloque las dependencias de su aplicación aquí; pertenecen // en el módulo individual build.gradle files}}

Abra su archivo build.gradle a nivel de módulo y encontrará una nueva entrada sceneform.asset () para su modelo 3D importado:

apply plugin: com.google.ar.sceneform.plugin // La "Ruta del activo de origen" que especificó durante la importación // sceneform.asset (sampledata / dinosaur.obj, // La "Ruta del material" que especificó durante la importación // Predeterminado , // La "Ruta de salida .sfa" que especificó durante la importación // sampledata / dinosaur.sfa, // La "Ruta de salida .sfb" que especificó durante la importación // src / main / assets / dinosaur)

Si echa un vistazo a sus carpetas "sampledata" y "raw", verá que contienen nuevos archivos .sfa y .sfb, respectivamente.

Puede obtener una vista previa del archivo .sfa en el nuevo Sceneform Viewer de Android Studio:

Seleccione "Ver> Herramientas Windows> Visor" en la barra de menú de Android Studio.
En el menú de la izquierda, seleccione su archivo .sfa. Su modelo 3D debería aparecer ahora en la ventana del Visor.

Muestra tu modelo 3D

Nuestra próxima tarea es crear una sesión de AR que comprenda su entorno y permita al usuario colocar modelos 3D en una escena aumentada.

Esto requiere que hagamos lo siguiente:

1. Crear una variable miembro ArFragment

ArFragment realiza gran parte del trabajo pesado que implica la creación de una sesión de AR, por lo que haremos referencia a este fragmento en toda nuestra clase MainActivity.

En el siguiente fragmento, estoy creando una variable miembro para ArFragment y luego la inicializo en el método onCreate ():

ArFragment privado arCoreFragment; @Override protected void onCreate (Bundle savedInstanceState) {super.onCreate (savedInstanceState); ... ... ...} setContentView (R.layout.activity_main); arCoreFragment = (ArFragment) // Encuentra el fragmento, usando el administrador de fragmentos // getSupportFragmentManager (). findFragmentById (R.id.main_fragment);

2. Construir un modelo Renderable

Ahora necesitamos transformar nuestro archivo .sfb en un ModelRenderable, que eventualmente representará nuestro objeto 3D.

Aquí, estoy creando un ModelRenderable del archivo res / raw / dinosaur .sfb de mi proyecto:

modelo privadoRenderable dinoRenderable; ... ... ... ModelRenderable.builder () .setSource (this, R.raw.dinosaur) .build () .thenAccept (renderable -> dinoRenderable = renderable) .exceptionally (arrojable -> {Log.e ( TAG, "No se puede cargar renderizable"); return null;}); }

3. Responder a la entrada del usuario

ArFragment tiene soporte incorporado para tocar, arrastrar, pellizcar y girar gestos.

En nuestra aplicación, el usuario agregará un modelo 3D a un Plano ARCore, al darle un toque a ese plano.

Para ofrecer esta funcionalidad, debemos registrar una devolución de llamada que se invocará cada vez que se toque un avión:

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

4. Ancla tu modelo

En este paso, recuperaremos un ArSceneView y lo adjuntaremos a un AnchorNode, que servirá como nodo principal de la escena.

ArSceneView es responsable de realizar varias tareas importantes de ARCore, incluida la representación de las imágenes de la cámara del dispositivo y la visualización de una animación de Sceneform UX que demuestra cómo el usuario debe sostener y mover su dispositivo para comenzar la experiencia de AR. ArSceneView también resaltará los planos que detecte, listos para que el usuario coloque sus modelos 3D dentro de la escena.

El componente ARSceneView tiene una escena adjunta, que es una estructura de datos padre-hijo que contiene todos los nodos que deben representarse.

Vamos a comenzar creando un nodo de tipo AnchorNode, que actuará como el nodo principal de nuestro ArSceneView.

Todos los nodos de anclaje permanecen en la misma posición del mundo real, por lo que al crear un nodo de anclaje nos aseguramos de que nuestros modelos 3D permanezcan fijos en su lugar dentro de la escena aumentada.

Vamos a crear nuestro nodo de anclaje:

AnchorNode anchorNode = nuevo AnchorNode (ancla);

Luego podemos recuperar un ArSceneView, usando getArSceneView (), y adjuntarlo al AnchorNode:

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

5. Agregue soporte para mover, escalar y rotar

A continuación, voy a crear un nodo de tipo TransformableNode. TransformableNode es responsable de mover, escalar y rotar nodos, en función de los gestos del usuario.

Una vez que haya creado un Nodo transformable, puede adjuntarlo Renderable, lo que le dará al modelo la capacidad de escalar y moverse, según la interacción del usuario. Finalmente, debe conectar el TransformableNode al AnchorNode, en una relación hijo-padre que garantice el TransformableNode y Los renderizables permanecen fijos en su lugar dentro de la escena aumentada.

TransformableNode transformableNode = new TransformableNode (arCoreFragment.getTransformationSystem ()); // Conecta transformableNode a anchorNode // transformableNode.setParent (anchorNode); transformableNode.setRenderable (dinoRenderable); // Seleccione el nodo // transformableNode.select (); }); }

La actividad principal completada

Después de realizar todo lo anterior, su MainActivity debería verse así:

importar android.app.Activity; importar android.app.ActivityManager; importar androidx.appcompat.app.AppCompatActivity; importar android.content.Context; importar android.net.Uri; importar android.os.Build; importar android.os.Build.VERSION_CODES; importar android.os.Bundle; importar android.util.Log; importar android.view.MotionEvent; importar androidx.annotation.RequiresApi; importar com.google.ar.core.Anchor; importar com.google.ar.core.HitResult; importar com.google.ar.core.Plane; importar com.google.ar.sceneform.AnchorNode; import com.google.ar.sceneform.rendering.ModelRenderable; importar com.google.ar.sceneform.ux.ArFragment; importar com.google.ar.sceneform.ux.TransformableNode; MainActivity de clase pública extiende AppCompatActivity {etiqueta de cadena final estática privada = MainActivity.class.getSimpleName (); privado estático final doble MIN_OPENGL_VERSION = 3.0; // Crear una variable miembro para ModelRenderable // private ModelRenderable dinoRenderable; // Crear una variable miembro para ArFragment // private ArFragment arCoreFragment; @RequiresApi (api = VERSION_CODES.N) @Override protected void onCreate (Bundle savedInstanceState) {super.onCreate (savedInstanceState); if (! checkDevice ((this))) {return; } setContentView (R.layout.activity_main); arCoreFragment = (ArFragment) // Encuentra el fragmento, usando el administrador de fragmentos // getSupportFragmentManager (). findFragmentById (R.id.main_fragment); if (Build.VERSION.SDK_INT> = VERSION_CODES.N) {// Construye el ModelRenderable // ModelRenderable.builder () .setSource (this, R.raw.dinosaur) .build () .thenAccept (renderable -> dinoRenderable = renderable ) .excepcionalmente (// Si se produce un error ... // arrojable -> {//... luego imprima lo siguiente en Logcat // Log.e (TAG, "No se puede cargar renderizable"); devuelva nulo;} ); } // Escuche los eventos onTap // arCoreFragment.setOnTapArPlaneListener ((HitResult hitResult, Plane plane, MotionEvent motionEvent) -> {if (dinoRenderable == null) {return;} Anchor anchor = hitResult.createAnchor (); // Build a nodo de tipo AnchorNode // AnchorNode anchorNode = new AnchorNode (anchor); // Conecte AnchorNode a la escena // anchorNode.setParent (arCoreFragment.getArSceneView (). getScene ()); // Cree un nodo de tipo TransformableNode // TransformableNode transformableNode = new TransformableNode (arCoreFragment.getTransformationSystem ()); // Conecte el TransformableNode al AnchorNode // transformableNode.setParent (anchorNode); // Adjunte Renderable // transformableNode.setRenderable (dinoRenderable); // Establezca el nodo / / transformableNode.select ();}); } public static boolean checkDevice (actividad de Actividad final) {// Si el dispositivo ejecuta Android Marshmallow o anterior ... // if (Build.VERSION.SDK_INT <VERSION_CODES.N) {//... luego imprima lo siguiente en Logcat // Log.e (TAG, "Sceneform requiere Android N o superior"); activity.finish (); falso retorno; } String openGlVersionString = ((ActivityManager) activity.getSystemService (Context.ACTIVITY_SERVICE)) .getDeviceConfigurationInfo () // Verifique la versión de OpenGL ES // .getGlEsVersion (); // Si el dispositivo ejecuta algo menos que OpenGL ES 3.0 ... // if (Double.parseDouble (openGlVersionString) <MIN_OPENGL_VERSION) {//... luego imprima lo siguiente en Logcat // Log.e (TAG, " Requiere OpenGL ES 3.0 o superior "); activity.finish (); falso retorno; } devuelve verdadero; }}

Puede descargar el proyecto completado desde GitHub.

Probar su aplicación de realidad aumentada Google ARCore

Ahora está listo para probar su aplicación en un dispositivo Android físico compatible. Si no posee un dispositivo que admita ARCore, entonces es posible probar su aplicación AR en el Emulador de Android (con un poco de configuración adicional, que veremos en la siguiente sección).

Para probar su proyecto en un físico Dispositivo Android:

Instale su aplicación en el dispositivo de destino.
Cuando se le solicite, otorgue a la aplicación acceso a la cámara de su dispositivo.
Si se le solicita que instale o actualice la aplicación ARCore, toque “Continuar” y luego complete el diálogo para asegurarse de que está ejecutando la última y mejor versión de ARCore.
Ahora debería ver una vista de cámara, completa con una animación de una mano sosteniendo un dispositivo. Apunte la cámara hacia una superficie plana y mueva su dispositivo con un movimiento circular, como lo demuestra la animación. Después de unos momentos, debería aparecer una serie de puntos, lo que indica que se ha detectado un avión.

Una vez que estés satisfecho con la posición de estos puntos, dales un toque: ¡tu modelo 3D ahora debería aparecer en el plano elegido!

Intente moverse físicamente alrededor del modelo; dependiendo de su entorno, es posible que pueda hacer los 360 grados completos a su alrededor. También debe verificar que el objeto esté proyectando una sombra que sea consistente con las fuentes de luz del mundo real.

Prueba de ARCore en un dispositivo virtual Android

Para probar sus aplicaciones ARCore en un dispositivo virtual Android (AVD), necesitará Android Emulator versión 27.2.9 o superior. También debe iniciar sesión en la tienda de Google Play en su AVD y tener OpenGL ES 3.0 o superior habilitado.

Para verificar si OpenGL ES 3.0 o superior está actualmente habilitado en su AVD:

Inicie su AVD, como de costumbre.
Abra una nueva ventana de Terminal (Mac) o un Símbolo del sistema (Windows).
Cambie el directorio ("cd") para que el Terminal / Símbolo del sistema apunte a la ubicación del programa "adb" de su SDK de Android, por ejemplo, mi comando se ve así:

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

Presione la tecla "Enter" en su teclado.
Copie / pegue el siguiente comando en la Terminal, y luego presione la tecla "Enter":

./adb logcat | grep eglMakeCurrent

Si la Terminal devuelve "ver 3 0" o superior, entonces OpenGL ES está configurado correctamente. Si la Terminal o el Símbolo del sistema muestra algo anterior a 3.0, deberá habilitar OpenGL ES 3.0:

Vuelva a su AVD.
Busque la tira de botones de "Control extendido" que flotan junto al emulador de Android y luego seleccione "Configuración> Avanzado".
Vaya a "Nivel de API de OpenGL ES> Máximo de renderizador (hasta OpenGL ES 3.1)".
Reinicia el emulador.

En la ventana Terminal / Símbolo del sistema, copie / pegue el siguiente comando y luego presione la tecla "Enter"

./adb logcat | grep eglMakeCurrent

Ahora debería obtener un resultado de "ver 3 0" o superior, lo que significa que OpenGL ES está configurado correctamente.

Finalmente, asegúrese de que su AVD esté ejecutando la última versión de ARCore:

Dirígete a la página GitHub de ARCore y descarga la última versión de ARCore para el emulador. Por ejemplo, en el momento de escribir este artículo, la versión más reciente era "ARCore_1.7.0.x86_for_emulator.apk"
Arrastre y suelte el APK en su AVD en ejecución.

Para probar su proyecto en un AVD, instale su aplicación y concédale acceso a la "cámara" del AVD cuando se le solicite.

Ahora debería ver una vista de cámara de una habitación simulada. Para probar su aplicación, muévase por este espacio virtual, encuentre una superficie plana simulada y haga clic para colocar un modelo en esta superficie.

Puede mover la cámara virtual por la sala virtual, manteniendo presionadas las teclas "Opción" (macOS) o "Alt" (Linux o Windows), y luego utilizando cualquiera de los siguientes métodos abreviados de teclado:

Mover hacia la izquierda o hacia la derecha. Presione A o D.
Mover hacia abajo o hacia arriba. Presione Q o E.
Avanzar o retroceder. Presione W o S.

También puede "moverse" alrededor de la escena virtual, presionando "Opción" o "Alt" y luego usando su mouse. Al principio, esto puede parecer un poco torpe, pero con la práctica debería poder explorar con éxito el espacio virtual. Una vez que encuentre un plano simulado, haga clic en los puntos blancos para colocar su modelo 3D en esta superficie.

Terminando

En este artículo, creamos una aplicación simple de realidad aumentada, utilizando ARCore y el complemento Sceneform.

Si decides usar Google ARCore en tus propios proyectos, ¡asegúrate de compartir tus creaciones en los comentarios a continuación!