Konfiguruję kamerę

Konfiguracje kamery opisują właściwości działającego w aplikacji czujnika aparatu. W Unity te konfiguracje są dostępne w menu XRCameraConfiguration.

Na platformie Android ARCore udostępnia element XRCameraConfigurationExtensions, który umożliwia wyświetlanie dodatkowych właściwości ARCore w XRCameraConfiguration. Korzystając z tych właściwości, możesz odpowiednio skonfigurować kamerę w swojej aplikacji.

Rozszerzone właściwości konfiguracji aparatu (Android)

ARCore na platformie Android obsługuje te rozszerzone właściwości:

• Używanie czujnika głębi
• Zakres docelowej liczby klatek w nagraniu kamery
• Wymiary tekstury zewnętrznej dostępnej dla GPU
• Kierunek, w którym skierowany jest aparat

Dostęp do obsługiwanych konfiguracji kamery

Użyj ARCameraManager.GetConfigurations(), aby uzyskać dostęp do obsługiwanych konfiguracji kamery na danym urządzeniu. Zwraca to tablicę NativeArray zawierającą wiele wystąpień elementu XRCameraConfiguration. Każdy z nich to osobna konfiguracja aparatu, która określa właściwości takie jak użycie głębi, docelową szybkość uchwycenia klatki, rozdzielczość i wymiary tekstury.

Konfigurowanie kamery w scenie aplikacji

Aby skonfigurować kamerę w scenie w aplikacji, wykonaj te czynności.

1. Użyj ARCameraManager z ARCameraManager.GetConfigurations(), aby zapytać o listę obsługiwanych XRCameraConfiguration.

2. Jeśli kompilujesz aplikację na Androida, użyj dowolnej kombinacji funkcji w pliku XRCameraConfigurationExtensions, aby uzyskać właściwości specyficzne dla ARCore.

3. Użyj elementu cameraManager.currentConfiguration, aby ustawić bieżącą konfigurację.

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;
    }
}

Filtry konfiguracji aparatu

Możesz użyć ARCoreExtensionsCameraConfigFilter, aby w czasie działania zawęzić dostępne konfiguracje kamery dla danego urządzenia, stosując filtrowanie na podstawie potrzeb aplikacji.

Ogranicz liczbę klatek na sekundę podczas rejestrowania przez kamerę do 30 FPS

Jeśli Twoja aplikacja nie potrzebuje szybszej liczby klatek w aparacie, możesz ją ustawić do 30 FPS. Na urządzeniach, które obsługują liczbę klatek na sekundę 60 FPS, ARCore będzie priorytetowo traktować konfiguracje aparatu, które domyślnie obsługują tę liczbę klatek. Aby odfiltrować wszystkie konfiguracje kamery obsługujące 60 FPS, sprawdź, czy w polu Target Camera Framerate ustawiona jest wartość Target 30FPS.

Nie zezwalaj ARCore na używanie czujnika głębi

Jeśli Twoja aplikacja nie wymaga Depth, możesz uniemożliwić ARCore używanie czujnika głębi. Na urządzeniach z obsługiwanym czujnikiem głębi ARCore traktuje priorytetowo konfiguracje aparatu, które korzystają z czujnika głębi. Aby odfiltrować wszystkie konfiguracje aparatu, które używają czujnika głębi, sprawdź, czy Depth Sensor Usage jest ustawiony na Do Not Use.

Używanie filtrów konfiguracji kamery

Aby umożliwić aplikacji filtrowanie konfiguracji kamery, wykonaj te czynności.

Aby utworzyć nowy filtr konfiguracji aparatu, otwórz Assets > Create > XR > Camera Config Filter.

Wybierz konfiguracje, których ma używać filtr.

Po utworzeniu filtra użyj go w komponencie ARCoreExtensions.

Konfigurowanie kamery w czasie działania

Możesz użyć zdarzenia wywołania zwrotnego ARCoreExtensions.OnChooseXRCameraConfiguration do skonfigurowania kamery w czasie działania na podstawie takich czynników jak typ urządzenia.

// 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;
}