Kamera konfigurieren

Kamerakonfigurationen beschreiben die Eigenschaften des zugrunde liegenden Kamerasensors einer App. In Unity kann auf diese Konfigurationen über XRCameraConfiguration zugegriffen werden.

Auf der Android-Plattform bietet ARCore XRCameraConfigurationExtensions, um zusätzliche ARCore-spezifische Attribute in XRCameraConfiguration verfügbar zu machen. Anhand dieser Eigenschaften können Sie die geeignete Kamerakonfiguration für Ihre Anwendung einrichten.

Erweiterte Kamerakonfigurationseigenschaften (Android)

Die folgenden erweiterten Attribute werden von ARCore auf der Android-Plattform unterstützt.

• Verwendung von Tiefensensoren
• Framerate für die Zielkameraaufnahme
• Die Abmessungen der GPU-zugänglichen externen Textur
• Richtung der Kamera

Auf unterstützte Kamerakonfigurationen zugreifen

Verwenden Sie ARCameraManager.GetConfigurations(), um auf die unterstützten Kamerakonfigurationen für ein bestimmtes Gerät zuzugreifen. Dadurch wird ein NativeArray zurückgegeben, das mehrere Instanzen von XRCameraConfiguration enthält. Jede Instanz ist eine individuelle Kamerakonfiguration, die Eigenschaften wie Tiefennutzung, Framerate für die Zielaufnahme, Auflösung und Texturabmessungen angibt.

Kamera in Ihrer App konfigurieren

Führen Sie die folgenden Schritte aus, um die Kamera in Ihrer App zu konfigurieren.

1. Verwenden Sie ARCameraManager mit ARCameraManager.GetConfigurations(), um die Liste der unterstützten XRCameraConfigurations abzufragen.

2. Wenn Sie Apps für Android entwickeln, können Sie eine beliebige Kombination der Funktionen in XRCameraConfigurationExtensions verwenden, um ARCore-spezifische Attribute zu erhalten.

3. Verwenden Sie cameraManager.currentConfiguration, um die aktuelle Konfiguration festzulegen.

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

Konfigurationsfilter für die Kamera

Mit ARCoreExtensionsCameraConfigFilter können Sie die verfügbaren Kamerakonfigurationen für ein bestimmtes Gerät zur Laufzeit eingrenzen, indem Sie nach den Anforderungen Ihrer App filtern.

Framerate der Kameraaufnahme auf 30 fps begrenzen

Wenn Ihre App keine höhere Kamera-Framerate benötigt, können Sie sie auf 30 fps begrenzen. Auf Geräten, die eine Kamera-Framerate von 60 fps unterstützen, priorisiert ARCore Kamerakonfigurationen, die diese Framerate standardmäßig unterstützen. Wenn Sie alle Kamerakonfigurationen herausfiltern möchten, die 60 fps unterstützen, muss Target Camera Framerate auf Target 30FPS gesetzt sein.

Verhindern, dass ARCore den Tiefensensor verwendet

Wenn für Ihre App keine Tiefe erforderlich ist, können Sie verhindern, dass ARCore den Tiefensensor verwendet. Auf Geräten mit einem unterstützten Tiefensensor priorisiert ARCore ARCore Kamerakonfigurationen, die den Tiefensensor verwenden. Wenn Sie alle Kamerakonfigurationen herausfiltern möchten, die den Tiefensensor verwenden, muss Depth Sensor Usage auf Do Not Use gesetzt sein.

Konfigurationsfilter der Kamera verwenden

Führen Sie die folgenden Schritte aus, damit Ihre App Kamerakonfigurationen filtern kann.

Rufen Sie Assets > Create > XR > Camera Config Filter auf, um einen neuen Kamerakonfigurationsfilter zu erstellen.

Wählen Sie die Konfigurationen aus, die der Filter verwenden soll.

Nachdem Sie den Filter erstellt haben, können Sie ihn in einer ARCoreExtensions-Komponente verwenden.

Kamera während der Laufzeit konfigurieren

Mit dem Callback-Ereignis ARCoreExtensions.OnChooseXRCameraConfiguration können Sie die Kamera während der Laufzeit basierend auf Faktoren wie dem Gerätetyp konfigurieren.

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