Kamera konfigurieren

Kamerakonfigurationen beschreiben die Eigenschaften des zugrunde liegenden Kamerasensors einer App. In Unity sind diese Konfigurationen über XRCameraConfiguration zugänglich.

Auf der Android-Plattform bietet ARCore XRCameraConfigurationExtensions, um zusätzliche ARCore-spezifische Properties in XRCameraConfiguration freizugeben. Mit diesen Eigenschaften können Sie die richtige Kamerakonfiguration für Ihre App einrichten.

Erweiterte Kamerakonfigurationseigenschaften (Android)

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

• Nutzung des Tiefensensors
• Bereich für die Framerate der Zielkamera
• Die Abmessungen der externen Textur, auf die die GPU zugreifen kann
• Richtung der Kamera

Auf unterstützte Kamerakonfigurationen zugreifen

Mit ARCameraManager.GetConfigurations() können Sie auf die unterstützten Kamerakonfigurationen für ein bestimmtes Gerät zugreifen. Dies gibt ein NativeArray mit mehreren Instanzen von XRCameraConfiguration zurück. Jede Instanz ist eine individuelle Kamerakonfiguration, in der Eigenschaften wie die Tiefennutzung, die Zielerfassungsframerate, die Auflösung und die Texturdimensionen angegeben werden.

Kamera in der Szene Ihrer App konfigurieren

So konfigurieren Sie die Kamera in der Szene Ihrer App:

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

2. Wenn Sie für Android entwickeln, verwenden Sie eine beliebige Kombination der Funktionen in XRCameraConfigurationExtensions, um ARCore-spezifische Eigenschaften abzurufen.

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

Filter für die Kamerakonfiguration

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 für Ihre App keine höhere Kamera-Framerate erforderlich ist, können Sie sie auf 30 fps begrenzen. Auf Geräten, die eine Kamera-Framerate von 60 fps unterstützen, priorisiert ARCore standardmäßig Kamerakonfigurationen, die diese Framerate unterstützen. Wenn du alle Kamerakonfigurationen herausfiltern möchtest, 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 Tiefeninformationen erforderlich sind, können Sie verhindern, dass ARCore den Tiefensensor verwendet. Auf Geräten mit einem unterstützten Tiefensensor werden von ARCore Kamerakonfigurationen priorisiert, 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.

Kamerakonfigurationsfilter verwenden

So aktivieren Sie in Ihrer App das Filtern von Kamerakonfigurationen:

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

Wählen Sie die Konfigurationen aus, die für den Filter verwendet werden sollen.

Verwenden Sie den Filter in einer ARCoreExtensions-Komponente.

Kamera während der Laufzeit konfigurieren

Sie können das Rückrufereignis ARCoreExtensions.OnChooseXRCameraConfiguration verwenden, um die Kamera während der Laufzeit basierend auf Faktoren wie dem Gerätetyp zu 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;
}