Como configurar a câmera

Importante: as configurações da câmera AR Foundation exigem as extensões do ARCore para AR Foundation. Verifique se as extensões estão instaladas e configuradas antes de continuar.

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

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

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

As seguintes propriedades estendidas são compatíveis com o ARCore na plataforma Android.

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

Acessar as 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 de câmera individual que especifica propriedades como uso de profundidade, taxa de quadros de captura de destino, resolução e dimensões da textura.

Observação: não copie nem armazene as instâncias de XRCameraConfiguration do NativeArray para uso posterior. Elas se tornam inválidas depois que os recursos nativos subjacentes são liberados.

Configurar a câmera na cena do app

Siga estas etapas para configurar a câmera no cenário 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 a taxa de quadros da captura da câmera a 30 QPS

Se o app não precisar de uma frame rate mais rápida da câmera, limite-a a 30 QPS. Em dispositivos com suporte a uma taxa de frames de 60 qps, o ARCore prioriza as configurações de câmera que oferecem suporte a essa taxa de frames por padrão. Para filtrar todas as configurações de câmera que oferecem suporte a 60 FPS, verifique se Target Camera Framerate está definido como Target 30FPS.

Impedir que o ARCore use o sensor de profundidade

Se o app não precisar de profundidade, você pode impedir que o ARCore use o sensor de profundidade. Em dispositivos com 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, verifique se Depth Sensor Usage está definido como Do Not Use.

Usar filtros de configuração da câmera

Siga estas etapas para permitir 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 a 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;
}