Advanced Signals - C# API

public class TimesyncRecorder : MonoBehaviour
{
    // In a real application you might want to persist this data to disk or use it from other parts of your
    // application to create synchronization points between the eye tracker clock and host system clock.
    private List<TobiiXR_AdvancedTimesyncData> _timesyncData = new List<TobiiXR_AdvancedTimesyncData>();

    private void Start()
    {
        StartCoroutine(TimesyncCoroutine());
    }

    private IEnumerator TimesyncCoroutine()
    {
        while (true)
        {
            // Start a timesync job asynchronously and receive a handle that can be used to poll
            // for the state of the job
            var handle = TobiiXR.Advanced.StartTimesyncJob();
            while (!handle.IsCompleted)
            {
                // Keep polling the handle every frame until it signals that the job has completed.
                yield return new WaitForEndOfFrame();
            }

            // Since the handle has signalled completed, the call to FinishTimesyncJob is no longer blocking
            var data = TobiiXR.Advanced.FinishTimesyncJob();
            if (data.HasValue)
            {
                // If the timesync operation completed successfully, we store the result to use for
                // interpolating gaze data.
                _timesyncData.Add(data.Value);
            }

            // Depending on how high accuracy you need for your use case, wait a number of seconds
            // before performing another timesync operation.
            yield return new WaitForSecondsRealtime(60);
        }
    }
}

public void PrintLatency()
{
    // Get the latest eye tracking data packet
    var data = TobiiXR.Advanced.LatestData;

    // Get a timestamp from the host system clock
    var now = TobiiXR.Advanced.GetSystemTimestamp();

    // Calculate system latency in milliseconds and print it
    var latency = (now - data.SystemTimestamp) / 1000.0f;
    Debug.Log(string.Format("System latency was {0:0.00} ms", latency));
}

{
    var transform = CameraHelper.GetCameraTransform(); // You could also use Camera.main.transform
    var data = TobiiXR.Advanced.LatestData;
    var origin = transform.TransformPoint(data.GazeRay.Origin);
    var direction = transform.TransformDirection(data.GazeRay.Direction);
}

using System.IO;
using Tobii.XR;
using UnityEngine;

public class EyeTrackingDataRecorder : MonoBehaviour
{
    private StreamWriter _dataFile;
    private bool _receivedData;

    private void Start()
    {
        // Create a file to record eye tracking data to
        var filePath = Path.Combine(Application.persistentDataPath, "recording.json");
        _dataFile = new StreamWriter(filePath);
        _dataFile.WriteLine("[");
    }

    private void Update()
    {
        // Dequeue all new data received since last frame
        while (TobiiXR.Advanced.QueuedData.Count > 0)
        {
            var data = TobiiXR.Advanced.QueuedData.Dequeue();

            // Serialize to json and append to file
            if (_receivedData) _dataFile.WriteLine(",");
            var json = JsonUtility.ToJson(data);
            _dataFile.Write(json);
            _receivedData = true;
        }
    }

    private void OnDestroy()
    {
        _dataFile.Write("]");

        // Make sure to close the file before terminating the application
        _dataFile.Close();
    }
}

{
    var et = TobiiXR.Advanced.LatestData;
    var mat = Matrix4x4.identity;
    if (!TobiiXR.Advanced.TryGetLocalToWorldMatrixFor(et.SystemTimestamp, out mat))
    {
        // TryGetLocalToWorldMatrixFor will only fail if no historic data has been recorded. Use predicted head pose in this case.
        mat = CameraHelper.GetCameraTransform().localToWorldMatrix;
    }
    var origin = mat.MultiplyPoint3x4(et.GazeRay.Origin);
    var direction = mat.MultiplyVector(et.GazeRay.Direction);
}