Contente

• Importando modelos 3D, com o plug-in Sceneform
• Instalando o Plug-in Sceneform
• Sceneform UX e Java 8: Atualizando as Dependências do Projeto
• Solicitando permissões com o ArFragment
• AR Necessário ou Opcional?
• 1. AR Necessário
• 2. AR Opcional
• Adicione o ArFragment ao seu layout
• Download de modelos 3D, usando o Poly do Google
• Importando modelos 3D para o Android Studio
• Exiba seu modelo 3D
• 1. Crie uma variável de membro ArFragment
• 2. Construa um ModelRenderable
• 3. Responda à entrada do usuário
• 4. Ancore seu modelo
• 5. Adicione suporte para mover, dimensionar e girar
• A MainActivity concluída
• Testando seu aplicativo de realidade aumentada do Google ARCore
• Testando o ARCore em um dispositivo virtual Android
• Empacotando

Importando modelos 3D, com o plug-in Sceneform

Normalmente, trabalhar com modelos 3D requer conhecimento especializado, mas com o lançamento do plug-in Sceneform, o Google tornou possível renderizar modelos 3D usando Java - e sem tendo que aprender OpenGL.

O plug-in Sceneform fornece uma API de alto nível que você pode usar para criar Renderdables a partir de widgets, formas ou materiais padrão do Android ou de recursos 3D, como arquivos .OBJ ou .FBX.

Em nosso projeto, usaremos o plug-in Sceneform para importar um arquivo .OBJ para o Android Studio. Sempre que você importa um arquivo usando o Sceneform, este plug-in automaticamente:

• Converta o arquivo do ativo em um arquivo .sfb. Este é um formato binário de Sceneform otimizado para tempo de execução (.sfb) que é adicionado ao APK e carregado no tempo de execução. Usaremos esse arquivo .sfb para criar um renderizável, que consiste em malhas, materiais e texturas, e pode ser colocado em qualquer lugar da cena aumentada.
• Gere um arquivo .sfa. Este é um arquivo de descrição de ativos, que é um arquivo de texto que contém uma descrição legível por humanos do arquivo .sfb. Dependendo do modelo, você poderá alterar sua aparência editando o texto dentro do arquivo .sfa.

Lembre-se de que, no momento da redação, o plug-in Sceneform ainda estava na versão beta, para que você possa encontrar bugs, erros ou outro comportamento estranho ao usar esse plug-in.

Instalando o Plug-in Sceneform

O plug-in Sceneform requer o Android Studio 3.1 ou superior. Se você não souber qual versão do Android Studio está usando, selecione "Android Studio> Sobre o Android Studio" na barra de ferramentas. O pop-up subsequente contém algumas informações básicas sobre a instalação do Android Studio, incluindo o número da versão.

Para instalar o plugin Sceneform:

• Se você estiver em um Mac, selecione "Android Studio> Preferências ..." na barra de ferramentas do Android Studio e escolha "Plugins" no menu à esquerda. Se você estiver em um PC com Windows, selecione "Arquivo> Configurações> Plugins> Procurar repositórios".
• Procure por “Sceneform”. Quando “Google Sceneform Tools” aparecer, selecione “Install”.
• Reinicie o Android Studio quando solicitado, e seu plug-in estará pronto para uso.

Sceneform UX e Java 8: Atualizando as Dependências do Projeto

Vamos começar adicionando as dependências que usaremos ao longo deste projeto. Abra o arquivo build.gradle no nível do módulo e adicione a biblioteca Sceneform UX, que contém o ArFragment que usaremos em nosso layout:

dependências {implementação fileTree (dir: libs, include:) implementação androidx.appcompat: appcompat: 1.0.2 implementação 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 // O Sceneform UX fornece recursos UX, incluindo ArFragment // implementação "com.google.ar.sceneform.ux: sceneform-ux: 1.7.0" deployment "com. android.support:appcompat-v7:28.0.0 "}

O Sceneform usa construções de linguagem do Java 8, portanto, também precisamos atualizar a Compatibilidade de origem e compatibilidade de destino do nosso projeto para Java 8:

compileOptions {sourceCompatibility JavaVersion.VERSION_1_8 targetCompatibility JavaVersion.VERSION_1_8}

Por fim, precisamos aplicar o plugin Sceneform:

aplicar plug-in: com.google.ar.sceneform.plugin

Seu arquivo build.gradle completo deve ser algo como isto:

aplique o plug-in: com.android.application android {compileSdkVersion 28 defaultConfig {applicationId "com.jessicathornsby.arcoredemo" minSdkVersion 23 targetSdkVersion 28 versionCode 1 versionName "1.0" testInstrumentationRunner "androidx.test.runner.AndroidJavaCompatibilityVersion_Validator.CompatibilityVersion JavaVersion.VERSION_1_8} buildTypes {release {minifyEnabled false proguardFiles getDefaultProguardFile (proguard-android-optimize.txt), proguard-rules.pro}}} dependências {implementação fileTree (dir: libs, include:) implementação androidx.appcompat: appcompat: 1.0 .2 implementação 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 deployment "com.google. ar.sceneform.ux: sceneform-ux: 1.7.0 "implementação" com.android.support:appcompat-v7:28.0.0 "} aplique o plug-in: com.google.ar .sceneform.plugin

Solicitando permissões com o ArFragment

Nosso aplicativo usará a câmera do dispositivo para analisar seus arredores e posicionar modelos 3D no mundo real. Antes que nosso aplicativo possa acessar a câmera, ele requer a permissão da câmera, então abra o Manifest do seu projeto e adicione o seguinte:

O Android 6.0 deu aos usuários a capacidade de conceder, negar e revogar permissões com permissão por permissão. Embora isso melhore a experiência do usuário, os desenvolvedores do Android agora precisam solicitar permissões manualmente em tempo de execução e lidar com a resposta do usuário. A boa notícia é que, ao trabalhar no Google ARCore, o processo de solicitar a permissão da câmera e lidar com a resposta do usuário é implementado automaticamente.

O componente ArFragment verifica automaticamente se o seu aplicativo tem permissão para a câmera e solicita, se necessário, antes de criar a sessão de recuperação garantida. Como usaremos o ArFragment em nosso aplicativo, não precisamos escrever nenhum código para solicitar a permissão da câmera.

AR Necessário ou Opcional?

Existem dois tipos de aplicativos que usam a funcionalidade de AR:

1. AR Necessário

Se seu aplicativo depende do Google ARCore para oferecer uma boa experiência ao usuário, você precisa garantir que ele seja baixado apenas em dispositivos compatíveis com o ARCore. Se você marcar seu aplicativo como "AR obrigatório", ele aparecerá apenas na loja Google Play, se o dispositivo suportar o ARCore.

Desde a nossa aplicação faz requerer o ARCore, abra o manifesto e adicione o seguinte:

Também é possível que seu aplicativo seja baixado para um dispositivo compatível com ARCore, em teoria, mas na verdade não tem o ARCore instalado. Quando marcarmos nosso aplicativo como "AR obrigatório", o Google Play baixará e instalará automaticamente o ARCore ao lado do seu aplicativo, se ele ainda não estiver presente no dispositivo de destino.

Lembre-se de que, mesmo que seu aplicativo seja android: obrigatório = "true", você ainda é necessário verificar se o ARCore está presente no tempo de execução, pois é possível que o usuário tenha desinstalado o ARCore desde o download do aplicativo ou se a versão do ARCore está desatualizada.

A boa notícia é que estamos usando o ArFragment, que verifica automaticamente se o ARCore está instalado e atualizado antes de criar cada Sessão de recuperação judicial - portanto, mais uma vez, isso não é necessário implementar manualmente.

2. AR Opcional

Se o seu aplicativo incluir recursos de recuperação de recursos que são interessantes, mas não essenciais para fornecer sua funcionalidade principal, você poderá marcar esse aplicativo como "AR Opcional". Seu aplicativo poderá verificar se o Google ARCore está presente em tempo de execução e desativar Recursos de AR em dispositivos que não oferecem suporte ao ARCore.

Se você criar um aplicativo "AR Opcional", o ARCore irá não seja instalado automaticamente junto com seu aplicativo, mesmo que o dispositivo possua todo o hardware e software necessário para oferecer suporte ao ARCore. Seu aplicativo “AR Opcional” precisará verificar se o ARCore está presente e atualizado e fazer o download da versão mais recente, conforme e quando necessário.

Se o ARCore não é crucial para o seu aplicativo, você pode adicionar o seguinte ao seu manifesto:

Embora eu tenha o Manifest aberto, também adiciono android: configChanges e android: screenOrientation, para garantir que MainActivity lide com as alterações de orientação normalmente.

Depois de adicionar tudo isso ao seu manifesto, o arquivo concluído deve se parecer com isso:

Adicione o ArFragment ao seu layout

Vou usar o ArFragment do ARCore, pois ele lida automaticamente com várias tarefas importantes do ARCore no início de cada sessão de AR. Mais notavelmente, o ArFragment verifica se uma versão compatível do ARCore está instalada no dispositivo e se o aplicativo atualmente tem a permissão da câmera.

Depois que o ArFragment verifica se o dispositivo pode suportar os recursos de recuperação de falhas do seu aplicativo, ele cria uma sessão do ArSceneView ARCore e a experiência de recuperação de falhas do seu aplicativo está pronta!

Você pode adicionar o fragmento ArFragment a um arquivo de layout, como um fragmento comum do Android, então abra seu arquivo activity_main.xml e adicione um componente "com.google.ar.sceneform.ux.ArFragment".

Download de modelos 3D, usando o Poly do Google

Existem várias maneiras diferentes de criar renderizáveis, mas neste artigo usaremos um arquivo de ativos 3D.

O Sceneform suporta recursos 3D nos formatos .OBJ, .glTF e .FBX, com ou sem animações. Existem muitos lugares onde você pode adquirir modelos 3D em um desses formatos suportados, mas neste tutorial eu usarei um arquivo .OBJ, baixado do repositório Poly do Google.

Acesse o site da Poly e faça o download do ativo que você deseja usar, no formato .OBJ (estou usando este modelo T-Rex).

• Descompacte a pasta, que deve conter o arquivo de ativos de origem do seu modelo (.OBJ, .FBX ou .glTF). Dependendo do modelo, essa pasta também pode conter algumas dependências do modelo, como arquivos nos formatos .mtl, .bin, .png ou .jpeg.

Importando modelos 3D para o Android Studio

Depois de ter seu ativo, é necessário importá-lo para o Android Studio usando o plug-in Sceneform. Este é um processo de várias etapas que requer que você:

• Crie uma pasta "sampledata". Sampledata é um novo tipo de pasta para dados de exemplo de tempo de design que não serão incluídos no APK, mas estarão disponíveis no editor do Android Studio.
• Arraste e solte o arquivo de ativo .OBJ original na pasta "sampledata".
• Execute a importação e a conversão do Sceneform no arquivo .OBJ, que gerará os arquivos .sfa e .sfb.

Embora possa parecer mais direto, não arraste e solte o arquivo .OBJ diretamente no diretório "res" do seu projeto, pois isso fará com que o modelo seja incluído no APK desnecessariamente.

Os projetos do Android Studio não contêm uma pasta "sampledata" por padrão, portanto, você precisará criar uma manualmente:

• Clique com a tecla Control pressionada na pasta "app" do seu projeto.
• Selecione "Novo> Diretório de dados de amostra" e crie uma pasta chamada "dados de amostra".
• Navegue até os arquivos de modelo 3D que você baixou anteriormente. Localize o arquivo do ativo de origem (.OBJ, .FBX ou .glTF) e arraste e solte-o no diretório "sampledata".
• Verifique se o seu modelo possui alguma dependência (como arquivos nos formatos .mtl, .bin, .png ou .jpeg). Se você encontrar algum desses arquivos, arraste e solte-os na pasta "sampledata".
• No Android Studio, clique com a tecla Control pressionada no arquivo de origem do modelo 3D (.OBJ, .FBX ou .glTF) e selecione "Importar recurso de forma de cena".

• A janela subseqüente exibe algumas informações sobre os arquivos que o Sceneform irá gerar, incluindo onde o arquivo .sfa resultante será armazenado no seu projeto; Vou usar o diretório "bruto".
• Quando estiver satisfeito com as informações inseridas, clique em "Concluir".

Essa importação faz algumas alterações no seu projeto. Se você abrir o arquivo build.gradle, verá que o plug-in Sceneform foi adicionado como uma dependência do projeto:

dependências {classpath com.android.tools.build:gradle:3.5.0-alpha06 classpath com.google.ar.sceneform: plugin: 1.7.0 // NOTA: Não coloque aqui as dependências de seu aplicativo; eles pertencem // aos arquivos build.gradle do módulo individual}}

Abra o arquivo build.gradle no nível do módulo e você encontrará uma nova entrada sceneform.asset () para o seu modelo 3D importado:

apply plugin: com.google.ar.sceneform.plugin // O "Caminho do ativo de origem" especificado durante a importação // sceneform.asset (sampledata / dinosaur.obj, // O "Caminho do material" especificado durante a importação // Padrão , // O “caminho de saída .sfa” que você especificou durante a importação // sampledata / dinosaur.sfa, // O “caminho de saída .sfa” que você especificou durante a importação // src / main / assets / dinosaur)

Se você der uma olhada nas pastas "sampledata" e "raw", verá que elas contêm novos arquivos .sfa e .sfb, respectivamente.

Você pode visualizar o arquivo .sfa, no novo Sceneform Viewer do Android Studio:

• Selecione "Exibir> Ferramentas Windows> Visualizador" na barra de menus do Android Studio.
• No menu à esquerda, selecione o seu arquivo .sfa. Seu modelo 3D agora deve aparecer na janela Visualizador.

Exiba seu modelo 3D

Nossa próxima tarefa é criar uma sessão de AR que entenda seus arredores e permita que o usuário coloque modelos 3D em uma cena aumentada.

Isso exige que façamos o seguinte:

1. Crie uma variável de membro ArFragment

O ArFragment realiza grande parte do trabalho pesado envolvido na criação de uma sessão de recuperação garantida, portanto, faremos referência a esse fragmento em toda a classe MainActivity.

No snippet a seguir, estou criando uma variável de membro para ArFragment e inicializando-a no método onCreate ():

private ArFragment arCoreFragment; @Override void protegido onCreate (Bundle savedInstanceState) {super.onCreate (savedInstanceState); ... ... ...} setContentView (R.layout.activity_main); arCoreFragment = (ArFragment) // Encontre o fragmento, usando o gerenciador de fragmentos // getSupportFragmentManager (). findFragmentById (R.id.main_fragment);

2. Construa um ModelRenderable

Agora precisamos transformar nosso arquivo .sfb em um ModelRenderable, que acabará renderizando nosso objeto 3D.

Aqui, estou criando um ModelRenderable a partir do arquivo res / raw / dinosaur .sfb do meu projeto:

private ModelRenderable dinoRenderable; ... ... ... ModelRenderable.builder () .setSource (this, R.raw.dinosaur) .build () .thenAccept (renderizável -> dinoRenderable = renderizável). Excepcionalmente (lançável -> {Log.e ( TAG, "Não foi possível carregar a renderização"); return null;}); }

3. Responda à entrada do usuário

O ArFragment possui suporte interno para gestos de tocar, arrastar, beliscar e torcer.

Em nosso aplicativo, o usuário adicionará um modelo 3D a um ARCore Plane, dando um toque nesse avião.

Para oferecer essa funcionalidade, precisamos registrar um retorno de chamada que será chamado sempre que um avião for tocado:

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

4. Ancore seu modelo

Nesta etapa, vamos recuperar um ArSceneView e anexá-lo a um AnchorNode, que servirá como o nó pai da cena.

O ArSceneView é responsável por executar várias tarefas importantes do ARCore, incluindo a renderização das imagens da câmera do dispositivo e a exibição de uma animação Sceneform UX que demonstra como o usuário deve segurar e mover o dispositivo para iniciar a experiência do AR. O ArSceneView também destacará todos os planos que detectar, prontos para o usuário colocar seus modelos 3D na cena.

O componente ARSceneView possui uma cena anexada, que é uma estrutura de dados pai-filho que contém todos os nós que precisam ser renderizados.

Começaremos criando um nó do tipo AnchorNode, que atuará como o nó pai do nosso ArSceneView.

Todos os nós de ancoragem permanecem na mesma posição do mundo real, portanto, ao criar um nó de ancoragem, garantimos que nossos modelos 3D permaneçam fixos na cena aumentada.

Vamos criar nosso nó âncora:

AnchorNode anchorNode = novo AnchorNode (âncora);

Podemos então recuperar um ArSceneView, usando getArSceneView (), e anexá-lo ao AnchorNode:

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

5. Adicione suporte para mover, dimensionar e girar

Em seguida, vou criar um nó do tipo TransformableNode. O TransformableNode é responsável por mover, dimensionar e girar nós, com base nos gestos do usuário.

Depois de criar um TransformableNode, você pode anexá-lo ao Renderable, que dará ao modelo a capacidade de dimensionar e mover, com base na interação do usuário. Por fim, você precisa conectar o TransformableNode ao AnchorNode, em um relacionamento pai-filho, o que garante que o TransformableNode e A renderização permanece fixa no local dentro da cena aumentada.

TransformableNode transformableNode = novo TransformableNode (arCoreFragment.getTransformationSystem ()); // Conecte transformableNode ao anchorNode // transformableNode.setParent (anchorNode); transformableNode.setRenderable (dinoRenderable); // Selecione o nó // transformableNode.select (); }); }

A MainActivity concluída

Depois de executar todas as opções acima, sua MainActivity deve ficar assim:

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; import 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; importar com.google.ar.sceneform.rendering.ModelRenderable; importar com.google.ar.sceneform.ux.ArFragment; importar com.google.ar.sceneform.ux.TransformableNode; classe pública MainActivity estende AppCompatActivity {final estático privado String TAG = MainActivity.class.getSimpleName (); duplo final estático privado MIN_OPENGL_VERSION = 3.0; // Crie uma variável de membro para ModelRenderable // private ModelRenderable dinoRenderable; // Crie uma variável de membro para ArFragment // private ArFragment arCoreFragment; @RequiresApi (api = VERSION_CODES.N) @Override void onCreate protegido (pacote salvoInstanceState) {super.onCreate (savedInstanceState); if (! checkDevice ((this))) {return; } setContentView (R.layout.activity_main); arCoreFragment = (ArFragment) // Encontre o fragmento, usando o gerenciador de fragmentos // getSupportFragmentManager (). findFragmentById (R.id.main_fragment); if (Build.VERSION.SDK_INT> = VERSION_CODES.N) {// Constrói o ModelRenderable // ModelRenderable.builder () .setSource (this, R.raw.dinosaur) .build () .thenAccept (renderizável -> dinoRenderable = renderizável ) .exceptionally (// Se ocorrer um erro ... // jogável -> {//..., imprima o seguinte no Logcat // Log.e (TAG, "Não é possível carregar o renderizável"); return null;} ); } // Ouça os eventos onTap // arCoreFragment.setOnTapArPlaneListener ((HitResult hitResult, plano de plano, MotionEvent motionEvent) -> {if (dinoRenderable == null) {return;} Anchor anchor = hitResult.createAnchor (); // Build a nó do tipo AnchorNode // AnchorNode anchorNode = new AnchorNode (anchor); // Conecte o AnchorNode à cena // anchorNode.setParent (arCoreFragment.getArSceneView (). getScene ()); // Crie um nó do tipo TransformableNode // TransformableNode transformableNode = new TransformableNode (arCoreFragment.getTransformationSystem ()); // Conecte o TransformableNode ao AnchorNode // transformableNode.setParent (anchorNode); // Anexe o Renderable // transformableNode.setRenderable (dinoRenderable); // Defina o nó / / transformableNode.select ();}); } checkDevice booleano estático público (atividade final da atividade) {// Se o dispositivo estiver executando o Android Marshmallow ou anterior ... // if (Build.VERSION.SDK_INT <VERSION_CODES.N) {//..., imprima o seguinte para Logcat // Log.e (TAG, "O Sceneform requer Android N ou superior"); activity.finish (); retorna falso; } String openGlVersionString = ((ActivityManager) activity.getSystemService (Context.ACTIVITY_SERVICE)) .getDeviceConfigurationInfo () // Verifique a versão do OpenGL ES // .getGlEsVersion (); // Se o dispositivo estiver executando algo menos que o OpenGL ES 3.0 ... // if (Double.parseDouble (openGlVersionString) <MIN_OPENGL_VERSION) {//..., imprima o seguinte em Logcat // Log.e (TAG, " Requer OpenGL ES 3.0 ou superior "); activity.finish (); retorna falso; } retornar verdadeiro; }}

Você pode baixar o projeto concluído no GitHub.

Testando seu aplicativo de realidade aumentada do Google ARCore

Agora você está pronto para testar seu aplicativo em um dispositivo Android físico suportado. Se você não possui um dispositivo compatível com ARCore, é possível testar seu aplicativo de AR no emulador do Android (com um pouco de configuração extra, que abordaremos na próxima seção).

Para testar seu projeto em um fisica Dispositivo Android:

• Instale seu aplicativo no dispositivo de destino.
• Quando solicitado, conceda ao aplicativo acesso à câmera do seu dispositivo.
• Se solicitado a instalar ou atualizar o aplicativo ARCore, toque em "Continuar" e conclua a caixa de diálogo para verificar se você está executando a versão mais recente e melhor do ARCore.
• Agora você deve ver uma visão da câmera, completa com a animação de uma mão segurando um dispositivo. Aponte a câmera para uma superfície plana e mova o dispositivo em um movimento circular, como demonstrado pela animação. Após alguns instantes, uma série de pontos deve aparecer, indicando que um avião foi detectado.

• Quando estiver satisfeito com a posição desses pontos, toque-os - seu modelo 3D agora deve aparecer no plano escolhido!

• Tente mover-se fisicamente pelo modelo; dependendo do ambiente, você poderá fazer 360 graus ao redor dele. Você também deve verificar se o objeto está projetando uma sombra consistente com as fontes de luz do mundo real.

Testando o ARCore em um dispositivo virtual Android

Para testar seus aplicativos ARCore em um dispositivo virtual Android (AVD), você precisará do Android Emulator versão 27.2.9 ou superior. Você também deve estar conectado à loja Google Play no seu AVD e ter o OpenGL ES 3.0 ou superior ativado.

Para verificar se o OpenGL ES 3.0 ou superior está atualmente ativado no seu AVD:

• Inicie o seu AVD, normalmente.
• Abra uma nova janela do Terminal (Mac) ou um prompt de comando (Windows).
• Alterar diretório ("cd") para que o Terminal / prompt de comando aponte para o local do programa "adb" do seu SDK para Android, por exemplo, meu comando se parece com o seguinte:

Cd / Usuários / jessicathornsby / Biblioteca / Android / sdk / platform-tools

• Pressione a tecla “Enter” no seu teclado.
• Copie / cole o próximo comando no Terminal e pressione a tecla “Enter”:

./adb logcat | grep eglMakeCurrent

Se o Terminal retornar “ver 3 0” ou superior, o OpenGL ES está configurado corretamente. Se o Terminal ou o Prompt de Comando exibir algo anterior ao 3.0, será necessário ativar o OpenGL ES 3.0:

• Volte para o seu AVD.
• Encontre a faixa dos botões "Controle estendido" que flutuam ao lado do emulador do Android e selecione "Configurações> Avançado".
• Navegue até “Nível da API do OpenGL ES> Máximo de renderizador (até OpenGL ES 3.1).”
• Reinicie o emulador.

Na janela Terminal / Prompt de Comando, copie / cole o seguinte comando e pressione a tecla “Enter”

./adb logcat | grep eglMakeCurrent

Agora você deve obter o resultado "ver 3 0" ou superior, o que significa que o OpenGL ES está configurado corretamente.

Por fim, verifique se o seu AVD está executando a versão mais recente do ARCore:

• Acesse a página do GitHub da ARCore e faça o download da versão mais recente do ARCore para o emulador. Por exemplo, no momento da redação, a versão mais recente era "ARCore_1.7.0.x86_for_emulator.apk"
• Arraste e solte o APK no seu AVD em execução.

Para testar seu projeto em um AVD, instale seu aplicativo e conceda-lhe acesso à "câmera" do AVD quando solicitado.

Agora você deve ver a câmera de uma sala simulada. Para testar seu aplicativo, mova-se por esse espaço virtual, encontre uma superfície plana simulada e clique para colocar um modelo nessa superfície.

Você pode mover a câmera virtual pela sala virtual, mantendo pressionadas as teclas “Option” (macOS) ou “Alt” (Linux ou Windows) e, em seguida, usando qualquer um dos seguintes atalhos de teclado:

• Mover para a esquerda ou direita. Pressione A ou D.
• Mover para baixo ou para cima. Pressione Q ou E.
• Avançar ou voltar. Pressione W ou S.

Você também pode "mover-se" pela cena virtual, pressionando "Option" ou "Alt" e, em seguida, usando o mouse. Isso pode parecer um pouco desajeitado no começo, mas com a prática, você poderá explorar com sucesso o espaço virtual. Depois de encontrar um plano simulado, clique nos pontos brancos para colocar seu modelo 3D nessa superfície.

Empacotando

Neste artigo, criamos um aplicativo simples de realidade aumentada, usando o ARCore e o plugin Sceneform.

Se você decidir usar o Google ARCore em seus próprios projetos, compartilhe suas criações nos comentários abaixo!