Yerel altyapıda genişletilmiş göz izleme

Makale
03/21/2023

Genişletilmiş göz izleme, HoloLens 2 yeni bir özelliktir. Yalnızca birleşik göz bakışı verileri sağlayan standart göz izlemenin üst kümesidir. Genişletilmiş göz izleme ayrıca tek tek göz bakışı verileri sağlar ve uygulamaların bakış verileri için 30, 60 ve 90fps gibi farklı kare hızları ayarlamasına olanak tanır. Göz açıklığı ve göz dalgalanması gibi diğer özellikler şu anda HoloLens 2 tarafından desteklenmiyor.

Genişletilmiş Göz İzleme SDK'sı, uygulamaların genişletilmiş göz izlemenin verilerine ve özelliklerine erişmesini sağlar. WinRT API'leri veya OpenXR API'leriyle birlikte kullanılabilir.

Bu makale, genişletilmiş göz izleme SDK'sını yerel altyapıda (C# veya C++/WinRT) WinRT API'leriyle birlikte kullanmanın yollarını kapsar.

Proje ayarları

Visual Studio 2019 veya Holographic DirectX 11 App (Universal Windows) (C++/WinRT) daha yeni bir Holographic DirectX 11 App (Universal Windows) sürümle veya proje oluşturun ya da mevcut holografik Visual Studio projenizi açın.
Genişletilmiş göz izleme SDK'sını projeye aktarın.
1. Visual Studio Çözüm Gezgini projenize sağ tıklayın -> NuGet Paketlerini Yönet...
2. Sağ üst köşedeki Paket kaynağının nuget.org gösterdiğinden emin olun: https://api.nuget.org/v3/index.json
3. Tarayıcı sekmesine tıklayın ve arama yapın Microsoft.MixedReality.EyeTracking.
4. SDK'nın en son sürümünü yüklemek için Yükle düğmesine tıklayın.
Bakış Girişi özelliğini ayarlama
1. Çözüm Gezgini'da Package.appxmanifest dosyasına çift tıklayın.
2. Özellikler sekmesine tıklayın ve ardından Bakış Girişi'ni denetleyin.

Head dosyasını dahil edin ve ad alanını kullanın.

C# projesi için:

using Microsoft.MixedReality.EyeTracking;

C++/WinRT projesi için:

#include <winrt/Microsoft.MixedReality.EyeTracking.h>
using namespace winrt::Microsoft::MixedReality::EyeTracking;

Genişletilmiş göz izleme SDK'ları API'lerini kullanın ve mantığınızı uygulayın.
HoloLens'i derleyin ve dağıtın.

Bakış verilerini alma adımlarına genel bakış

Genişletilmiş Göz İzleme SDK'sı API'leri aracılığıyla göz bakışı verilerini almak için aşağıdaki adımlar gerekir:

Kullanıcıdan Göz İzleme özelliklerine erişim elde edin.
Göz bakışı izleyici bağlantılarını ve bağlantı kesilmelerini izleyin.
Göz bakışı izleyicisini açın ve özelliklerini sorgulayın.
Göz bakışı izleyicisinden sürekli olarak bakış verilerini okuyun.
Bakış verilerini diğer SpatialCoordinateSystems'a aktarabilirsiniz.

Göz izleme özelliklerine erişim elde etme

Gözle ilgili bilgileri kullanabilmek için uygulamanın önce kullanıcı onayı istemesi gerekir.

var status = await Windows.Perception.People.EyesPose.RequestAccessAsync();
bool useGaze = (status == Windows.UI.Input.GazeInputAccessStatus.Allowed);

auto accessStatus = co_await winrt::Windows::Perception::People::EyesPose::RequestAccessAsync();
bool useGaze = (accessStatus.get() == winrt::Windows::UI::Input::GazeInputAccessStatus::Allowed);

Göz bakışı izleyicisini algılama

Göz bakışı izleyici algılama, sınıfın EyeGazeTrackerWatcher kullanımıyla yapılır. EyeGazeTrackerAdded ve EyeGazeTrackerRemoved olaylar sırasıyla bir göz bakışı izleyicisi algılandığında veya bağlantısı kesildiğinde tetiklenir.

İzleyici açıkça yöntemiyle StartAsync() başlatılmalıdır. Bu yöntem, zaten bağlı olan izleyicilere olay üzerinden EyeGazeTrackerAdded sinyal gönderildiğinde zaman uyumsuz olarak tamamlanır.

Bir göz bakışı izleyicisi algılandığında, olay parametrelerinde EyeGazeTrackerAdded uygulamaya bir EyeGazeTracker örnek geçirilir; karşılıklı olarak, izleyicinin bağlantısı kesildiğinde ilgili EyeGazeTracker örnek EyeGazeTrackerRemoved olayına geçirilir.

EyeGazeTrackerWatcher watcher = new EyeGazeTrackerWatcher();
watcher.EyeGazeTrackerAdded += _watcher_EyeGazeTrackerAdded;
watcher.EyeGazeTrackerRemoved += _watcher_EyeGazeTrackerRemoved;
await watcher.StartAsync();
...

private async void _watcher_EyeGazeTrackerAdded(object sender, EyeGazeTracker e)
{
    // Implementation is in next section
}

private void _watcher_EyeGazeTrackerRemoved(object sender, EyeGazeTracker e)
{
    ...
}

EyeGazeTrackerWatcher watcher;
watcher.EyeGazeTrackerAdded(std::bind(&SampleEyeTrackingNugetClientAppMain::OnEyeGazeTrackerAdded, this, _1, _2));
watcher.EyeGazeTrackerRemoved(std::bind(&SampleEyeTrackingNugetClientAppMain::OnEyeGazeTrackerRemoved, this, _1, _2));
co_await watcher.StartAsync();
...

winrt::Windows::Foundation::IAsyncAction SampleAppMain::OnEyeGazeTrackerAdded(const EyeGazeTrackerWatcher& sender, const EyeGazeTracker& tracker)
{
    // Implementation is in next section
}
void SampleAppMain::OnEyeGazeTrackerRemoved(const EyeGazeTrackerWatcher& sender, const EyeGazeTracker& tracker)
{
    ...
}

Göz bakışı izleyicisini açma

Bir EyeGazeTracker örneği alırken uygulamanın önce yöntemini çağırarak açması OpenAsync() gerekir. Daha sonra gerekirse izleyici özelliklerini sorgulayabilir. OpenAsync() yöntemi bir boole parametresi alır; bu, uygulamanın tek tek göz bakışı vektörleri veya izleyicinin kare hızını değiştirme gibi standart gözle izlemeye ait olmayan özelliklere erişmesi gerekip gerekmediğini gösterir.

Birleşik bakış, tüm göz bakışı izleyicileri tarafından desteklenen zorunlu bir özelliktir. Tek tek bakışa erişim gibi diğer özellikler isteğe bağlıdır ve izleyiciye ve sürücüsüne bağlı olarak desteklenebilir veya desteklenmeyebilir. Bu isteğe bağlı özellikler için sınıfı, özelliğin EyeGazeTracker desteklenip desteklenmediğini belirten bir özellik (örneğin, AreLeftAndRightGazesSupported tek tek göz bakışı bilgilerinin cihaz tarafından desteklenip desteklenmediğini gösteren özellik) kullanıma sunar.

Göz bakışı izleyicisi tarafından ortaya çıkan tüm uzamsal bilgiler, dinamik düğüm kimliğiyle tanımlanan izleyicinin kendisiyle ilgili olarak yayımlanır. WinRT API'leri ile bir SpatialCoordinateSystem elde etmek için nodeId değerini kullanmak, bakış verilerinin koordinatlarını başka bir koordinat sistemine dönüştürebilir.

private async void _watcher_EyeGazeTrackerAdded(object sender, EyeGazeTracker e)
{
    try
    {
        // Try to open the tracker with access to restricted features
        await e.OpenAsync(true);

        // If it has succeeded, store it for future use
        _tracker = e;

        // Check support for individual eye gaze
        bool supportsIndividualEyeGaze = _tracker.AreLeftAndRightGazesSupported;

        // Get a spatial locator for the tracker, this will be used to transfer the gaze data to other coordinate systems later
        var trackerNodeId = e.TrackerSpaceLocatorNodeId;
        _trackerLocator = Windows.Perception.Spatial.Preview.SpatialGraphInteropPreview.CreateLocatorForNode(trackerNodeId);
    }
    catch (Exception ex)
    {
        // Unable to open the tracker
    }
}

winrt::Windows::Foundation::IAsyncAction SampleEyeTrackingNugetClientAppMain::OnEyeGazeTrackerAdded(const EyeGazeTrackerWatcher&, const EyeGazeTracker& tracker)
{
   auto newTracker = tracker;

   try
   {
        // Try to open the tracker with access to restricted features
        co_await newTracker.OpenAsync(true);

        // If it has succeeded, store it for future use
        m_gazeTracker = newTracker;

        // Check support for individual eye gaze
        const bool supportsIndividualEyeGaze = m_gazeTracker.AreLeftAndRightGazesSupported();

        // Get a spatial locator for the tracker. This will be used to transfer the gaze data to other coordinate systems later
        const auto trackerNodeId = m_gazeTracker.TrackerSpaceLocatorNodeId();
        m_trackerLocator = winrt::Windows::Perception::Spatial::Preview::SpatialGraphInteropPreview::CreateLocatorForNode(trackerNodeId);
   }
   catch (const winrt::hresult_error& e)
   {
       // Unable to open the tracker
   }
}

Göz bakışı izleyici kare hızını ayarlama

özelliği, EyeGazeTracker.SupportedTargetFrameRates izleyici tarafından desteklenen hedef kare hızının listesini döndürür. HoloLens 2 30, 60 ve 90fps'yi destekler.

EyeGazeTracker.SetTargetFrameRate() Hedef kare hızını ayarlamak için yöntemini kullanın.

// This returns a list of supported frame rate: 30, 60, 90 fps in order
var supportedFrameRates = _tracker.SupportedTargetFrameRates;

// Sets the tracker at the highest supported frame rate (90 fps)
var newFrameRate = supportedFrameRates[supportedFrameRates.Count - 1];
_tracker.SetTargetFrameRate(newFrameRate);
uint newFramesPerSecond = newFrameRate.FramesPerSecond;

// This returns a list of supported frame rate: 30, 60, 90 fps in order
const auto supportedFrameRates = m_gazeTracker.SupportedTargetFrameRates();

// Sets the tracker at the highest supported frame rate (90 fps)
const auto newFrameRate = supportedFrameRates.GetAt(supportedFrameRates.Size() - 1);
m_gazeTracker.SetTargetFrameRate(newFrameRate);
const uint32_t newFramesPerSecond = newFrameRate.FramesPerSecond();

Göz bakışı izleyicisinden bakış verilerini okuma

Göz bakışı izleyicisi, durumlarını düzenli aralıklarla döngüsel arabellekte yayımlar. Bu, uygulamanın izleyicinin durumunu küçük bir zaman aralığına ait bir zamanda okumasını sağlar. Örneğin, izleyicinin en son durumunun veya kullanıcıdan el hareketi gibi bir olay sırasındaki durumunun alınmasına izin verir.

örnek olarak EyeGazeTrackerReading izleyici durumunu alan yöntemler:

TryGetReadingAtTimestamp() ve TryGetReadingAtSystemRelativeTime() yöntemleri, uygulama tarafından geçirilen süreye en yakın değeri döndürürEyeGazeTrackerReading. İzleyici yayımlama zamanlamasını denetler, bu nedenle döndürülen okuma istek zamanından biraz daha eski veya daha yeni olabilir. EyeGazeTrackerReading.Timestamp ve EyeGazeTrackerReading.SystemRelativeTime özellikleri, uygulamanın yayımlanan durumun tam zamanını bilmesini sağlar.
TryGetReadingAfterTimestamp() ve TryGetReadingAfterSystemRelativeTime() yöntemleri, parametre olarak geçirilen zamandan kesinlikle daha üstün bir zaman damgası ile ilkini EyeGazeTrackerReading döndürür. Bu, bir uygulamanın izleyici tarafından yayımlanan tüm durumları sırayla okumasını sağlar. Tüm bu yöntemlerin mevcut arabelleği sorguladıklarını ve hemen döndürdüğünü unutmayın. Kullanılabilir durum yoksa null döndürür (başka bir deyişle, uygulamanın bir durumun yayımlanmasını beklemesini sağlamaz).

Zaman damgasına ek olarak, bir EyeGazeTrackerReading örneğin göz izleyicisi kalibrasyonunun geçerli olup olmadığını gösteren bir IsCalibrationValid özelliği vardır.

Son olarak, bakış verileri veya TryGetLeftEyeGazeInTrackerSpace()gibi TryGetCombinedEyeGazeInTrackerSpace() bir yöntem kümesi aracılığıyla alınabilir. Bu yöntemlerin tümü başarılı olduğunu belirten bir boole değeri döndürür. Bazı verilerin alınamaması, verilerin desteklenmediği (EyeGazeTracker bu durumu algılayan özelliklere sahip olduğu) veya izleyicinin verileri alamadığı (örneğin geçersiz kalibrasyon veya göz gizlendiği) anlamına gelebilir.

Örneğin, uygulama birleştirilmiş bakışa karşılık gelen bir imleç görüntülemek istiyorsa, aşağıdaki gibi hazırlanan çerçevenin tahmininin zaman damgasını kullanarak izleyiciyi sorgulayabilir.

var holographicFrame = holographicSpace.CreateNextFrame();
var prediction = holographicFrame.CurrentPrediction;
var predictionTimestamp = prediction.Timestamp;
var reading = _tracker.TryGetReadingAtTimestamp(predictionTimestamp.TargetTime.DateTime);
if (reading != null)
{
    // Vector3 needs the System.Numerics namespace
    if (reading.TryGetCombinedEyeGazeInTrackerSpace(out Vector3 gazeOrigin, out Vector3 gazeDirection))
    {
        // Use gazeOrigin and gazeDirection to display the cursor
    }
}

auto holographicFrame = m_holographicSpace.CreateNextFrame();
auto prediction = holographicFrame.CurrentPrediction();
auto predictionTimestamp = prediction.Timestamp();
const auto reading = m_gazeTracker.TryGetReadingAtTimestamp(predictionTimestamp.TargetTime());
if (reading)
{
    float3 gazeOrigin;
    float3 gazeDirection;
    if (reading.TryGetCombinedEyeGazeInTrackerSpace(gazeOrigin, gazeDirection))
    {
        // Use gazeOrigin and gazeDirection to display the cursor
    }
}

Bakış verilerini diğer SpatialCoordinateSystem'a dönüştürme

Konum gibi uzamsal verileri döndüren WinRT API'leri her zaman hem hem PerceptionTimestampSpatialCoordinateSystemhem de gerektirir. Örneğin, WinRT API'sini kullanarak HoloLens 2 birleşik bakışını almak için SpatialPointerPose.TryGetAtTimestamp() API'sinde iki parametre gerekir: a SpatialCoordinateSystem ve .PerceptionTimestamp Birleşik bakışa üzerinden SpatialPointerPose.Eyes.Gazeerişildiğinde, bunun başlangıcı ve yönü geçirilen içinde SpatialCoordinateSystem ifade edilir.

Genişletilmiş boya izleme SDK'sı API'lerinin bir SpatialCoordinateSystem alması gerekmez ve bakış verileri her zaman izleyicinin koordinat sisteminde gösterilir. Ancak izleyicinin diğer koordinat sistemiyle ilgili pozuyla bu bakış verilerini başka bir koordinat sistemine dönüştürebilirsiniz.

Yukarıdaki "Açık göz bakışı izleyicisi" adlı bölümde belirtildiği gibi, göz bakışı izleyicisi için bir SpatialLocator almak için özelliğiyle çağrısı Windows.Perception.Spatial.Preview.SpatialGraphInteropPreview.CreateLocatorForNode() yapın EyeGazeTracker.TrackerSpaceLocatorNodeId .
Bakış noktaları ve üzerinden EyeGazeTrackerReading alınan yol tarifleri, göz bakışı izleyicisi ile ilgilidir.
SpatialLocator.TryLocateAtTimestamp() , bir Matrix4x4 dönüştürme matrisi oluşturmak için kullanılabilecek belirli PerceptionTimeStamp bir ve ile SpatialCoordinateSystemilgili göz bakışı izleyicisinin tam 6DoF konumunu döndürür.
Bakış çıkış noktalarını ve yönlerini diğer SpatialCoordinateSystem'e aktarmak için, inşa edilmiş Matrix4x4 dönüştürme matrisini kullanın.

Aşağıdaki kod örnekleri, birleştirilmiş bakış yönünde, bakış kaynağının iki metre önünde bulunan bir küp konumunun nasıl hesaplanmış olduğunu gösterir;

var predictionTimestamp = prediction.Timestamp;
var stationaryCS = stationaryReferenceFrame.CoordinateSystem;
var trackerLocation = _trackerLocator.TryLocateAtTimestamp(predictionTimestamp, stationaryCS);
if (trackerLocation != null)
{
    var trackerToStationaryMatrix = Matrix4x4.CreateFromQuaternion(trackerLocation.Orientation) * Matrix4x4.CreateTranslation(trackerLocation.Position);
    var reading = _tracker.TryGetReadingAtTimestamp(predictionTimestamp.TargetTime.DateTime);
    if (reading != null)
    {
        if (reading.TryGetCombinedEyeGazeInTrackerSpace(out Vector3 gazeOriginInTrackerSpace, out Vector3 gazeDirectionInTrackerSpace))
        {
            var cubePositionInTrackerSpace = gazeOriginInTrackerSpace + 2.0f * gazeDirectionInTrackerSpace;
            var cubePositionInStationaryCS = Vector3.Transform(cubePositionInTrackerSpace, trackerToStationaryMatrix);
        }
    }
}

auto predictionTimestamp = prediction.Timestamp();
auto stationaryCS = m_stationaryReferenceFrame.CoordinateSystem();
auto trackerLocation = m_trackerLocator.TryLocateAtTimestamp(predictionTimestamp, stationaryCS);
if (trackerLocation) 
{
    auto trackerOrientation = trackerLocation.Orientation();
    auto trackerPosition = trackerLocation.Position();
    auto trackerToStationaryMatrix = DirectX::XMMatrixRotationQuaternion(DirectX::XMLoadFloat4(reinterpret_cast<const DirectX::XMFLOAT4*>(&trackerOrientation))) * DirectX::XMMatrixTranslationFromVector(DirectX::XMLoadFloat3(&trackerPosition));

    const auto reading = m_gazeTracker.TryGetReadingAtTimestamp(predictionTimestamp.TargetTime());
    if (reading)
    {
        float3 gazeOriginInTrackerSpace;
        float3 gazeDirectionInTrackerSpace;
        if (reading.TryGetCombinedEyeGazeInTrackerSpace(gazeOriginInTrackerSpace, gazeDirectionInTrackerSpace))
        {
            auto cubePositionInTrackerSpace = gazeOriginInTrackerSpace + 2.0f * gazeDirectionInTrackerSpace;
            float3 cubePositionInStationaryCS;
            DirectX::XMStoreFloat3(&cubePositionInStationaryCS, DirectX::XMVector3TransformCoord(DirectX::XMLoadFloat3(&cubePositionInTrackerSpace), trackerToStationaryMatrix));
        }
    }
}

Genişletilmiş göz izleme SDK'sının API başvurusu

namespace Microsoft.MixedReality.EyeTracking
{
    /// <summary>
    /// Allow discovery of Eye Gaze Trackers connected to the system
    /// This is the only class from Extended Eye Tracking SDK that the application will instantiate, 
    /// other classes' instances will be returned by method calls or properties.
    /// </summary>
    public class EyeGazeTrackerWatcher
    {
        /// <summary>
        /// Constructs an instance of the watcher
        /// </summary>
        public EyeGazeTrackerWatcher();

        /// <summary>
        /// Starts trackers enumeration.
        /// </summary>
        /// <returns>Task representing async action; completes when the initial enumeration is completed</returns>
        public System.Threading.Tasks.Task StartAsync();

        /// <summary>
        /// Stop listening to trackers additions and removal
        /// </summary>
        public void Stop();

        /// <summary>
        /// Raised when an Eye Gaze tracker is connected
        /// </summary>
        public event System.EventHandler<EyeGazeTracker> EyeGazeTrackerAdded;

        /// <summary>
        /// Raised when an Eye Gaze tracker is disconnected
        /// </summary>
        public event System.EventHandler<EyeGazeTracker> EyeGazeTrackerRemoved;        
    }

    /// <summary>
    /// Represents an Eye Tracker device
    /// </summary>
    public class EyeGazeTracker
    {
        /// <summary>
        /// True if Restricted mode is supported, which means the driver supports to provide individual 
        /// eye gaze vector and framerate 
        /// </summary>
        public bool IsRestrictedModeSupported;

        /// <summary>
        /// True if Vergence Distance is supported by tracker
        /// </summary>
        public bool IsVergenceDistanceSupported;

        /// <summary>
        /// True if Eye Openness is supported by the driver
        /// </summary>
        public bool IsEyeOpennessSupported;

        /// <summary>
        /// True if individual gazes are supported
        /// </summary>
        public bool AreLeftAndRightGazesSupported;

        /// <summary>
        /// Get the supported target frame rates of the tracker
        /// </summary>
        public System.Collections.Generic.IReadOnlyList<EyeGazeTrackerFrameRate> SupportedTargetFrameRates;

        /// <summary>
        /// NodeId of the tracker, used to retrieve a SpatialLocator or SpatialGraphNode to locate the tracker in the scene
        /// for Perception API, use SpatialGraphInteropPreview.CreateLocatorForNode
        /// for Mixed Reality OpenXR API, use SpatialGraphNode.FromDynamicNodeId
        /// </summary>
        public Guid TrackerSpaceLocatorNodeId;

        /// <summary>
        /// Opens the tracker
        /// </summary>
        /// <param name="restrictedMode">True if restricted mode active</param>
        /// <returns>Task representing async action; completes when the initial enumeration is completed</returns>
        public System.Threading.Tasks.Task OpenAsync(bool restrictedMode);

        /// <summary>
        /// Closes the tracker
        /// </summary>
        public void Close();

        /// <summary>
        /// Changes the target frame rate of the tracker
        /// </summary>
        /// <param name="newFrameRate">Target frame rate</param>
        public void SetTargetFrameRate(EyeGazeTrackerFrameRate newFrameRate);

        /// <summary>
        /// Try to get tracker state at a given timestamp
        /// </summary>
        /// <param name="timestamp">timestamp</param>
        /// <returns>State if available, null otherwise</returns>
        public EyeGazeTrackerReading TryGetReadingAtTimestamp(DateTime timestamp);

        /// <summary>
        /// Try to get tracker state at a system relative time
        /// </summary>
        /// <param name="time">time</param>
        /// <returns>State if available, null otherwise</returns>
        public EyeGazeTrackerReading TryGetReadingAtSystemRelativeTime(TimeSpan time);

        /// <summary>
        /// Try to get first first tracker state after a given timestamp
        /// </summary>
        /// <param name="timestamp">timestamp</param>
        /// <returns>State if available, null otherwise</returns>
        public EyeGazeTrackerReading TryGetReadingAfterTimestamp(DateTime timestamp);

        /// <summary>
        /// Try to get the first tracker state after a system relative time
        /// </summary>
        /// <param name="time">time</param>
        /// <returns>State if available, null otherwise</returns>
        public EyeGazeTrackerReading TryGetReadingAfterSystemRelativeTime(TimeSpan time);
    }

    /// <summary>
    /// Represents a Frame Rate supported by an Eye Tracker
    /// </summary>
    public class EyeGazeTrackerFrameRate
    {
        /// <summary>
        /// Frames per second of the frame rate
        /// </summary>
        public UInt32 FramesPerSecond;
    }

    /// <summary>
    /// Snapshot of Gaze Tracker state
    /// </summary>
    public class EyeGazeTrackerReading
    {
        /// <summary>
        /// Timestamp of state
        /// </summary>
        public DateTime Timestamp;

        /// <summary>
        /// Timestamp of state as system relative time
        /// Its SystemRelativeTime.Ticks could provide the QPC time to locate tracker pose 
        /// </summary>
        public TimeSpan SystemRelativeTime;

        /// <summary>
        /// Indicates user calibration is valid
        /// </summary>
        public bool IsCalibrationValid;

        /// <summary>
        /// Tries to get a vector representing the combined gaze related to the tracker's node
        /// </summary>
        /// <param name="origin">Origin of the gaze vector</param>
        /// <param name="direction">Direction of the gaze vector</param>
        /// <returns></returns>
        public bool TryGetCombinedEyeGazeInTrackerSpace(out System.Numerics.Vector3 origin, out System.Numerics.Vector3 direction);

        /// <summary>
        /// Tries to get a vector representing the left eye gaze related to the tracker's node
        /// </summary>
        /// <param name="origin">Origin of the gaze vector</param>
        /// <param name="direction">Direction of the gaze vector</param>
        /// <returns></returns>
        public bool TryGetLeftEyeGazeInTrackerSpace(out System.Numerics.Vector3 origin, out System.Numerics.Vector3 direction);

        /// <summary>
        /// Tries to get a vector representing the right eye gaze related to the tracker's node position
        /// </summary>
        /// <param name="origin">Origin of the gaze vector</param>
        /// <param name="direction">Direction of the gaze vector</param>
        /// <returns></returns>
        public bool TryGetRightEyeGazeInTrackerSpace(out System.Numerics.Vector3 origin, out System.Numerics.Vector3 direction);

        /// <summary>
        /// Tries to read vergence distance
        /// </summary>
        /// <param name="value">Vergence distance if available</param>
        /// <returns>bool if value is valid</returns>
        public bool TryGetVergenceDistance(out float value);

        /// <summary>
        /// Tries to get left Eye openness information
        /// </summary>
        /// <param name="value">Eye Openness if valid</param>
        /// <returns>bool if value is valid</returns>
        public bool TryGetLeftEyeOpenness(out float value);

        /// <summary>
        /// Tries to get right Eye openness information
        /// </summary>
        /// <param name="value">Eye Openness if valid</param>
        /// <returns>bool if value is valid</returns>
        public bool TryGetRightEyeOpenness(out float value);
    }
}

Ayrıca bkz.

Unity'de genişletilmiş göz izlemeyi kullanma

Share via