Технологии дополненной реальности (Augmented Reality, AR) развиваются с первых экспериментов с шлемами в 1968 году и прогнозируются как один из быстрорастущих сегментов развития интерфейсов (особенно при появлении специализированных устройств, таких как Hololens, Xiaomi Smart Glasses и проекта с непонятной судьбой Google Glass). Не могли не заметить этот тренд и разработчики операционных систем для мобильных устройств, Apple выпустила свой набор инструментов ARKit, также как и Google создала набор библиотек ARCore. Особенно важно, что поддержка этих библиотек доступна на большом количестве устройств (для Android нужна версия 7.0 или новее, а это более 94% доступных устройств, при этом почти 90% из них поддерживают Depth API, необходимый для корректной работы алгоритмов размещения объектов виртуального мира в сложном окружении). В этой статье мы рассмотрим основные вопросы использования ARCore и размещения объектов виртуального мира над поверхностями реального.

Прежде всего нужно убедиться, что ваш телефон поддерживает ARCore, для этого необходимо установить Google Play Services for AR по ссылке. В любом случае для разработки можно использовать эмулятор. Для корректной работы на эмуляторе нужно установить этот пакет (версия для эмулятора).

При создании приложения необходимо указать минимальную версию SDK 24, а также необходимость использования AR и, если использование ARCore критично для основной функциональности приложения, также отметить его как Required, например так (в AndroidManifest.xml):

<uses-feature android:name="android.hardware.camera.ar" />

<application>
    <meta-data android:name="com.google.ar.core" android:value="required" />
</application>

Также в коде должны быть выполнены вызовы ArCoreApk.checkAvailability() для проверки доступности библиотеки и ArCoreApk.requestInstall() для перехода к установке библиотеки. Также в зависимости проекта нужно добавить библиотеку:

dependencies {
//...
  implementation("com.google.ar:core:1.36.0")
}

Добавим в onCreate в MainActivity проверку доступности AR:

        val availability = ArCoreApk.getInstance().checkAvailability(this)
        println("AR is supported: ${availability.isSupported}")

Если возвращается значение true, то мы можем использовать функциональность библиотеки иначе можно запросить установку ArCore:

        if (!availability.isSupported) {
            val result = ArCoreApk.getInstance().requestInstall(this, false)
            when (result) {
                ArCoreApk.InstallStatus.INSTALLED -> println("Do some work")
                ArCoreApk.InstallStatus.INSTALL_REQUESTED ->  println("Just wait for user actions")
            }
        }

Поскольку дополненная реальность использует камеру телефона, то нужно дополнительно объявить и запросить разрешение для камеры, добавим в AndroidManifest.xml

    <uses-feature
        android:name="android.hardware.camera"
        android:required="false" />

    <uses-permission android:name="android.permission.CAMERA"/>

И запросим runtime-разрешение для доступа к камере (CAMERA_REQUEST_CODE=1000):

when (PackageManager.PERMISSION_GRANTED) {
    ContextCompat.checkSelfPermission(
        this,
        Manifest.permission.CAMERA
    ) -> {
        println("Do some job")
    }
    else -> {
        requestPermissions(
            arrayOf(Manifest.permission.CAMERA),
            CAMERA_REQUEST_CODE
        )
    }
}

и также обработаем результат действия выдачи разрешения (если было запрошено):

override fun onRequestPermissionsResult(
    requestCode: Int,
    permissions: Array<out String>,
    grantResults: IntArray
) {
    super.onRequestPermissionsResult(requestCode, permissions, grantResults)
    if (requestCode== CAMERA_REQUEST_CODE) {
        if (grantResults.first() == PackageManager.PERMISSION_GRANTED) {
            println("Do some work with camera")
        }
    }
}

Все взаимодействие с библиотекой выполняется через сессию:

import com.google.ar.core.Config
import com.google.ar.core.Session

lateinit var session: Session

fun onCreate() {

    //...инициализация...
  
    session = Session(config)
    val config = Config(session)
    //здесь можно изменить конфигурацию
    //например setFocusMode устанавливает режим фокусировки
    //также можно управлять алгоритмами поиска поверхностей (setPlaneFindingMode),
    //включать поддержку режима глубины (setDepthMode), управлять способами обнаружения
    //источников освещения (setLightEstimationMode) и т.д.
    session.configure(config)
}

fun onDestroy() {
    session.close()
}

Для создания объектов 3D-сцены будут использоваться возможности OpenGL ES, для этого на сцену необходимо поместить View с типом GLSurfaceView (activity_main.xml):

<?xml version="1.0" encoding="utf-8"?>
<androidx.constraintlayout.widget.ConstraintLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context=".MainActivity">

    <android.opengl.GLSurfaceView
        android:id="@+id/surface"
        android:layout_width="match_parent"
        android:layout_height="match_parent"/>
    
</androidx.constraintlayout.widget.ConstraintLayout>

Выполним инициализацию контекста и присоединим класс для отрисовки сцены:

        val surface = findViewById<GLSurfaceView>(R.id.surface)
        surface.setRenderer(MainRenderer())
        surface.requestRender()

Сам класс MainRenderer будет наследоваться от android.opengl.GLSurfaceView.Renderer и определять следующие методы:

    override fun onSurfaceCreated(gl: GL10?, config: EGLConfig?) {
        println("Surface created")
        //здесь нужно выполнить инициализацию контекста
    }

    override fun onSurfaceChanged(gl: GL10?, width: Int, height: Int) {
        println("Surface changed")
        //здесь можно обновить контекст (например, размеры сцены)
    }

    override fun onDrawFrame(gl: GL10?) {
        println("Draw frame")
        val frame = session.update()
        //... логика отрисовки
    }

Здесь наиболее важным является объект frame, который позволяет как получить доступ к актуальному изображению с камеры и получить результаты распознавания источников света, ключевых точек, поверхностей или поз, например:

• acquireCameraImage() извлекает текущее изображение с камеры;

• acquireRawDepthImage16Bits()получить карту глубины для изображения;

• getLightEstimate() обнаруживает фоновый источник освещения (если это разрешено в конфигурации);

• getUpdatedAnchors() получает список обнаруженных точек привязки (используются для позиционирования объектов в дополненной реальности, могут быть созданы над любым обнаруженным объектом или точкой на поверхности.

Из сессии можно получить информацию об отслеживаемых объектах (включая поверхности) следующим образом:

session.getAllTrackables<Plane>(Plane::class.java)

Также сейчас поддерживается GeoSpatial API для позиционирования объектов с привязкой к географическим координатам (через session.earth), что может быть полезно для отображения подсказок при навигации, визуализации исторических изображений при посещении достопримечательностей и т.д.

Поскольку для отображения на сцене требуется работать с GL-текстурами, удобно использовать готовый рендерер, который умеет работать с фоновым изображением, отображением 3D-моделей и собственных шейдеров. Например можно взять пример отсюда, где поддерживается работа с моделями в формате WaveFront (.obj) и текстурами в PNG. Также можно использовать любую библиотеку для работы поверх EGL.

Наиболее просто начать разработку AR приложения с базового шаблона hello_ar_kotlin, в котором реализовано отображение фоновой текстуры (изображение с камеры), карты глубины, возможность загрузки 3D-моделей и примеры для добавления объектов к якорным точкам (с отслеживанием положения точки при изменении изображения на камере). В этом проекте есть дополнительные helper-классы, упрощающие управление жизненным циклом сессии ARCore и запрос необходимых разрешений (ARCoreSessionLifecycleHelper). Также Sample Renderer представляет базовый класс, который дает возможность загружать 3D-модели и текстуры, отображать растровые изображения как текстуру (класс FrameBuffer), например, изображение с камер, через BackgroundRenderer, работать с 3D-объектами и трансформировать их в набор полигонов (а также загружать из WaveFront OBJ-файла) в классе Mesh, загружать текстуры (класс Texture). В примере можно увидеть как используется поиск поверхностей и добавления якорных точек для размещения 3D-объектов:

Для добавления виртуального объекта необходимо в onSurfaceCreated загрузить mesh (3D-сетку из obj-файла) и текстуры для поверхности и отражения:

      virtualObjectAlbedoInstantPlacementTexture =
        Texture.createFromAsset(
          render,
          "models/pawn_albedo_instant_placement.png",
          Texture.WrapMode.CLAMP_TO_EDGE,
          Texture.ColorFormat.SRGB
        )

      val virtualObjectPbrTexture =
        Texture.createFromAsset(
          render,
          "models/pawn_roughness_metallic_ao.png",
          Texture.WrapMode.CLAMP_TO_EDGE,
          Texture.ColorFormat.LINEAR
        )
      virtualObjectMesh = Mesh.createFromAsset(render, "models/pawn.obj")
      virtualObjectShader =
        Shader.createFromAssets(
            render,
            "shaders/environmental_hdr.vert",
            "shaders/environmental_hdr.frag",
            mapOf("NUMBER_OF_MIPMAP_LEVELS" to cubemapFilter.numberOfMipmapLevels.toString())
          )
          .setTexture("u_AlbedoTexture", virtualObjectAlbedoTexture)
          .setTexture("u_RoughnessMetallicAmbientOcclusionTexture", virtualObjectPbrTexture)
          .setTexture("u_Cubemap", cubemapFilter.filteredCubemapTexture)
          .setTexture("u_DfgTexture", dfgTexture)

Для отображения обнаруженных поверхностей используется класс PlaneRenderer (в onDraw):

val projectionMatrix = FloatArray(16)
camera.getProjectionMatrix(projectionMatrix, 0, Z_NEAR, Z_FAR)

planeRenderer.drawPlanes(
      render,
      session.getAllTrackables<Plane>(Plane::class.java),
      camera.displayOrientedPose,
      projectionMatrix
    )

Визуализация присоединенных к якорным точкам объектов выполняется аналогично с использованием матрицы для преобразования экранных координат в мировую систему координат:

    val viewMatrix = FloatArray(16)
    val projectionMatrix = FloatArray(16)
    val modelViewMatrix = FloatArray(16) // view x model
    val modelViewProjectionMatrix = FloatArray(16) // projection x view x model

    camera.getViewMatrix(viewMatrix, 0)

    Matrix.multiplyMM(modelViewProjectionMatrix, 0, projectionMatrix, 0, viewMatrix, 0)

    for ((anchor, trackable) in
      wrappedAnchors.filter { it.anchor.trackingState == TrackingState.TRACKING }) {
      // Get the current pose of an Anchor in world space. The Anchor pose is updated
      // during calls to session.update() as ARCore refines its estimate of the world.
      anchor.pose.toMatrix(modelMatrix, 0)

      // Calculate model/view/projection matrices
      Matrix.multiplyMM(modelViewMatrix, 0, viewMatrix, 0, modelMatrix, 0)
      Matrix.multiplyMM(modelViewProjectionMatrix, 0, projectionMatrix, 0, modelViewMatrix, 0)

      // Update shader properties and draw
      virtualObjectShader.setMat4("u_ModelView", modelViewMatrix)
      virtualObjectShader.setMat4("u_ModelViewProjection", modelViewProjectionMatrix)
      val texture =
        if ((trackable as? InstantPlacementPoint)?.trackingMethod ==
            InstantPlacementPoint.TrackingMethod.SCREENSPACE_WITH_APPROXIMATE_DISTANCE
        ) {
          virtualObjectAlbedoInstantPlacementTexture
        } else {
          virtualObjectAlbedoTexture
        }
      virtualObjectShader.setTexture("u_AlbedoTexture", texture)
      render.draw(virtualObjectMesh, virtualObjectShader, virtualSceneFramebuffer)
    }

Для добавления якорной точки координаты нажатия на экране преобразуются в координаты на обнаруженной поверхности:

    val hitResultList = frame.hitTest(tap)

    //находим ближайший к нам
    val firstHitResult =
      hitResultList.firstOrNull { hit ->
        when (val trackable = hit.trackable!!) {
          is Plane ->
            trackable.isPoseInPolygon(hit.hitPose) &&
              PlaneRenderer.calculateDistanceToPlane(hit.hitPose, camera.pose) > 0
          is Point -> trackable.orientationMode == Point.OrientationMode.ESTIMATED_SURFACE_NORMAL
          is InstantPlacementPoint -> true
          is DepthPoint -> true
          else -> false
        }
      }

    if (firstHitResult != null) {
      wrappedAnchors.add(WrappedAnchor(firstHitResult.createAnchor(), firstHitResult.trackable))
    }

Поскольку ARCore принимает на себя основные задачи по обнаружению и отслеживанию объектов (может распознавать двумерные объекты на данный момент, а также есть эксперименты с обнаружение 3D-объектов с использование ARCore ML), поверхностей, точек (например, угловых точек 3D-объектов для измерения расстояний), то в большинстве случае остается только решить задачу позиционирования и ориентировки 3D-объектов по указанным координатам и размещения источников света в виртуальной сцене для корректной визуализации бликов и теней на создаваемых объектах и здесь уже начинается работа с низкоуровневыми методами библиотеки EGL и преобразованиями координат, которые могут быть реализованы через дополнительные библиотеки, например libgdx.

В завершение приглашаю вас на бесплатный урок, в рамках которого рассмотрим Jetpack Compose - современный тулкит от компании Google для создания приложений под ОС Android на языке программирования Kotlin. Jetpack Compose упрощает написание и обновление визуального интерфейса приложения, предоставляя декларативный подход.

• Зарегистрироваться на бесплатный урок