Como configurar a câmera

As configurações da câmera descrevem as propriedades do sensor subjacente da câmera de um app. No Unity, essas configurações podem ser acessadas usando XRCameraConfiguration.

Na plataforma Android, o ARCore oferece XRCameraConfigurationExtensions para expor outras propriedades específicas do ARCore em XRCameraConfiguration. É possível usar essas propriedades para definir a configuração adequada da câmera para seu app.

Propriedades estendidas da configuração da câmera (Android)

As propriedades estendidas a seguir têm suporte do ARCore na plataforma Android.

• Uso do sensor de profundidade
• Intervalo para frame rate de captura da câmera de destino
• As dimensões da textura externa acessível pela GPU
• Direção da câmera

Acessar configurações de câmera compatíveis

Use ARCameraManager.GetConfigurations() para acessar as configurações de câmera com suporte em um determinado dispositivo. Isso retorna um NativeArray contendo várias instâncias de XRCameraConfiguration. Cada instância é uma configuração individual de câmera que especifica propriedades como uso de profundidade, frame rate de captura de destino, resolução e dimensões de textura.

Configurar a câmera na cena do seu app

Siga estas etapas para configurar a câmera na cena do seu app.

1. Use ARCameraManager com ARCameraManager.GetConfigurations() para consultar a lista de XRCameraConfigurations compatíveis.

2. Se você estiver criando para Android, use qualquer combinação das funções em XRCameraConfigurationExtensions para receber propriedades específicas do ARCore.

3. Use cameraManager.currentConfiguration para definir a configuração atual.

using UnityEngine.XR.ARFoundation;


// Adds XRCameraConfigurationExtensions extension methods to XRCameraConfiguration.
// This is for the Android platform only.
using Google.XR.ARCoreExtensions;

// Must be set in the editor.
public ARCameraManager cameraManager;

// Use ARCameraManager to obtain the camera configurations.
using (NativeArray<XRCameraConfiguration> configurations = cameraManager.GetConfigurations(Allocator.Temp))
{
    if (!configurations.IsCreated || (configurations.Length <= 0))
    {
        return;
    }

    // Iterate through the list of returned configs to locate the config you want.
    var desiredConfig = configurations[0];
    for (int i = 1; i < configurations.Length; ++i)
    {
        // Choose a config for a given camera that uses the maximum
        // target FPS and texture dimension. If supported, this config also enables
        // the depth sensor.
        if (configurations[i].GetFPSRange().y > desiredConfig.GetFPSRange().y &&
            configurations[i].GetTextureDimensions().x > desiredConfig.GetTextureDimensions().x &&
            configurations[i].GetTextureDimensions().y > desiredConfig.GetTextureDimensions().y &&
            configurations[i].CameraConfigDepthSensorUsage() == CameraConfigDepthSensorUsage.RequireAndUse)
        {
            desiredConfig = configurations[i];
        }
    }

    // Set the configuration you want. If it succeeds, the session
    // automatically pauses and resumes to apply the new configuration.
    // If it fails, cameraManager.currentConfiguration throws an exception.
    if (desiredConfig != cameraManager.currentConfiguration)
    {
        cameraManager.currentConfiguration = desiredConfig;
    }
}

Filtros de configuração da câmera

É possível usar ARCoreExtensionsCameraConfigFilter para restringir as configurações de câmera disponíveis para um determinado dispositivo durante a execução, filtrando com base nas necessidades do app.

Limitar o frame rate de captura da câmera a 30 QPS

Se o app não precisa de um frame rate mais rápido da câmera, você pode limitar esse recurso a 30 QPS. Em dispositivos compatíveis com um frame rate de câmera de 60 QPS, o ARCore vai priorizar as configurações da câmera que oferecem suporte a esse frame rate por padrão. Para filtrar todas as configurações da câmera com suporte a 60 QPS, confira se Target Camera Framerate está definido como Target 30FPS.

Impedir que o ARCore use o sensor de profundidade

Se o app não exigir a Profundidade, você pode impedir que o ARCore use o sensor de profundidade. Em dispositivos que têm um sensor de profundidade compatível, o ARCore prioriza as configurações da câmera que usam o sensor de profundidade. Para filtrar todas as configurações da câmera que usam o sensor de profundidade, confira se Depth Sensor Usage está definido como Do Not Use.

Usar filtros de configuração da câmera

Siga estas etapas para que seu app filtre as configurações da câmera.

Acesse Assets > Create > XR > Camera Config Filter para criar um novo filtro de configuração da câmera.

Selecione as configurações que você quer que o filtro use.

Depois de criar o filtro, use-o em um componente ARCoreExtensions.

Configurar a câmera durante o tempo de execução

Você pode usar o evento de callback ARCoreExtensions.OnChooseXRCameraConfiguration para configurar a câmera durante o tempo de execução com base em fatores como o tipo de dispositivo.

// Unity's Awake() method
public void Awake()
{
    …
    // If the return value is not a valid index (ex. the value if -1),
    // then no camera configuration will be set. If no previous selection exists, 
    // the ARCore session will use the previously selected camera configuration 
    // or a default configuration.
    arcoreExtensions.OnChooseXRCameraConfiguration = SelectCameraConfiguration;
    …
}

// A custom camera configuration selection function
int SelectCameraConfiguration(List<XRCameraConfiguration> supportedConfigurations)
{
    int index = 0;

    // Use custom logic here to choose the desired configuration from supportedConfigurations.

    return index;
}