private void ProcessGazeEvents()
{
const int maxIterations = 20;
var gazeData = _latestGazeData;
for (int i = 0; i < maxIterations; i++)
{
var originalGaze = _originalGazeData.Next;
// Queue empty
if (originalGaze == null)
{
break;
}
var bestMatchingPose = _eyeTrackerOriginPoses.GetBestMatchingPose(originalGaze.SystemTimeStamp);
if (!bestMatchingPose.Valid)
{
Debug.Log("Did not find a matching pose");
continue;
}
gazeData = new VRGazeData(originalGaze, bestMatchingPose);
_gazeDataQueue.Next = gazeData;
}
var queueCount = UnprocessedGazeDataCount;
if (queueCount > 0)
{
Debug.LogWarning("We didn't manage to empty the queue: " + queueCount + " items left...");
}
_latestGazeData = gazeData;
}
private void Update()
{
//Only attempt recording if the eyetracker is connected.
if (!eyeTracker.Connected)
{
return;
}
//Toggle recording on or off if the recording button is pressed.
if (Input.GetKeyDown(recordButton))
{
ToggleRecording();
}
//Handle the data objects from the eye tracker each frame.
while (eyeTracker.GazeDataCount > 0)
{
//The eyetracker will still enqueue data even if it's not used, this removes data not used by the recorder.
//ATTENTION: This will remove all data not used by this object. If you want to use the eye tracking data in other objects, please make a class that stores it and then passes it here.
IVRGazeData nextData = eyeTracker.NextData;
if (record)
{
//If we are recording, convert the eyetracking data to gaze data objects and write them to the buffer.
EnqueueGazeData(EncodeGazeData(nextData));
}
//This is only here for the demo scene. Ugly solution, but fast.
if (HMDDemo.GazeRaycaster.instance != null && nextData.CombinedGazeRayWorldValid)
{
HMDDemo.GazeRaycaster.instance.Raycast(nextData.CombinedGazeRayWorld);
}
}
}
string FormatInputToCsv(IVRGazeData input)
{
Vector3 headDirection = input.Pose.Rotation * Vector3.forward;
Vector2 gazePosLeft = input.Left.PupilPosiitionInTrackingArea;
Vector2 gazePosRight = input.Right.PupilPosiitionInTrackingArea;
Vector2 gazePoint = new Vector2((gazePosLeft.x + gazePosRight.x) / 2, (gazePosLeft.y + gazePosRight.y) / 2);
double t1X = target1.x / cam.pixelWidth;
double t1Y = 1 - target1.y / cam.pixelHeight;
double t2X = target2.x / cam.pixelWidth;
double t2Y = 1 - target2.y / cam.pixelHeight;
// Debug.Log ("play1: " + tX + " " + tY);
// Debug.Log ("gaze " + gazePoint.x + " " + gazePoint.y);
string line = string.Format(
"{0},{1},{2},{3},{4},{5},{6},{7}, {8}",
number,
(Time.unscaledTime - recordingStart).ToString(),
currTobiiTime,
gazePoint.x,
gazePoint.y,
t1X,
t1Y,
t2X,
t2Y
);
// Debug.Log (line);
return(line);
}
// Update is called once per frame
void Update()
{
Tobii.Research.Unity.VREyeTracker _tobiiEyeTracker = Tobii.Research.Unity.VREyeTracker.Instance;
if (_tobiiEyeTracker != null && _tobiiEyeTracker.Connected)
{
IVRGazeData last_ivrGazeData = _tobiiEyeTracker.LatestGazeData;
// set SaveInfo dic
SaveInfo = new Dictionary <string, Dictionary <string, string> > {
};
// Timestamp
if (last_ivrGazeData.OriginalGaze != null) //)
{
SaveInfo.AddToNestedDictionary("Time", "DeviceTimeStamp", last_ivrGazeData.OriginalGaze.DeviceTimeStamp.ToString());
SaveInfo.AddToNestedDictionary("Time", "SystemTimeStamp", last_ivrGazeData.OriginalGaze.SystemTimeStamp.ToString());
// print ( last_ivrGazeData.OriginalGaze.DeviceTimeStamp.ToString ());
}
// Head
SaveInfo.AddToNestedDictionary("Head", "Position_X", last_ivrGazeData.Pose.Position.x.ToString(FORMAT_FLOAT));
SaveInfo.AddToNestedDictionary("Head", "Position_Y", last_ivrGazeData.Pose.Position.y.ToString(FORMAT_FLOAT));
SaveInfo.AddToNestedDictionary("Head", "Position_Z", last_ivrGazeData.Pose.Position.z.ToString(FORMAT_FLOAT));
SaveInfo.AddToNestedDictionary("Head", "Rotation_X", last_ivrGazeData.Pose.Rotation.eulerAngles.x.ToString(FORMAT_FLOAT));
SaveInfo.AddToNestedDictionary("Head", "Rotation_Y", last_ivrGazeData.Pose.Rotation.eulerAngles.y.ToString(FORMAT_FLOAT));
SaveInfo.AddToNestedDictionary("Head", "Rotation_Z", last_ivrGazeData.Pose.Rotation.eulerAngles.z.ToString(FORMAT_FLOAT));
// combined gaze
SaveInfo.AddToNestedDictionary("CombinedGaze", "RayOrigin_X", last_ivrGazeData.CombinedGazeRayWorld.origin.x.ToString(FORMAT_FLOAT));
SaveInfo.AddToNestedDictionary("CombinedGaze", "RayOrigin_Y", last_ivrGazeData.CombinedGazeRayWorld.origin.y.ToString(FORMAT_FLOAT));
SaveInfo.AddToNestedDictionary("CombinedGaze", "RayOrigin_Z", last_ivrGazeData.CombinedGazeRayWorld.origin.z.ToString(FORMAT_FLOAT));
SaveInfo.AddToNestedDictionary("CombinedGaze", "RayDirection_X", last_ivrGazeData.CombinedGazeRayWorld.direction.x.ToString(FORMAT_FLOAT));
SaveInfo.AddToNestedDictionary("CombinedGaze", "RayDirection_Y", last_ivrGazeData.CombinedGazeRayWorld.direction.y.ToString(FORMAT_FLOAT));
SaveInfo.AddToNestedDictionary("CombinedGaze", "RayDirection_Z", last_ivrGazeData.CombinedGazeRayWorld.direction.z.ToString(FORMAT_FLOAT));
// Eye
// left
WriteTobiiEyeData("LeftEye", last_ivrGazeData.Left);
// right
WriteTobiiEyeData("RightEye", last_ivrGazeData.Right);
SaveData.Instance.AddToList(SaveInfo);
}
}
//Turn a data object from the eye tracker into a custom gaze tracker object, ready to be serialized.
private HMDGazeData EncodeGazeData(IVRGazeData _IVRGazeData)
{
if (_IVRGazeData == null)
{
return(null);
}
HMDGazeData gazeData = new HMDGazeData();
gazeData.valid = _IVRGazeData.CombinedGazeRayWorldValid;
gazeData.timestamp = Time.time;
Vector3 viewportPoint = Vector3.zero;
if (gazeData.valid)
{
viewportPoint = GazeToViewportPoint(mainCamera, _IVRGazeData.CombinedGazeRayWorld.direction);
}
string objectName = "None";
float distance = lastDistance;
if (raycast)
{
RaycastHit hit;
if (Physics.Raycast(_IVRGazeData.CombinedGazeRayWorld, out hit))
{
distance = hit.distance;
lastDistance = distance;
GameObject target = hit.collider.gameObject;
if (target != null)
{
objectName = target.name;
}
}
}
else
{
objectName = "Not Tracked";
}
gazeData.viewPortPoint = viewportPoint;
gazeData.distance = distance;
gazeData.origin = _IVRGazeData.CombinedGazeRayWorld.origin;
gazeData.direction = _IVRGazeData.CombinedGazeRayWorld.direction;
gazeData.objectName = objectName;
gazeData.pupilsValid = IsPupilDataValid(_IVRGazeData);
gazeData.pupilSize = AveragePupilDiameter(_IVRGazeData);
return(gazeData);
}
void WriteToFileCsv(IVRGazeData input)
{
if (input != null)
{
currTobiiTime = input.TimeStamp;
if (FormatInputToCsv(input) == null)
{
// Debug.Log ("There is nothing");
}
sw.WriteLine(FormatInputToCsv(input));
}
}
private void WriteResult(IVRGazeData gazeData)
{
_file.WriteStartElement("Gaze");
_file.WriteStartElement("Left");
_file.WriteStartElement("Ray");
_file.WriteAttributeString("valid", gazeData.Left.GazeRayWorldValid.ToString());
_file.WriteAttributeString("timestamp", gazeData.TimeStamp.ToString());
_file.WriteAttributeString("origin", gazeData.Left.GazeRayWorld.origin.ToString("0000.00000000"));
_file.WriteAttributeString("direction", gazeData.Left.GazeRayWorld.direction.ToString("0000.00000000"));
_file.WriteEndElement();
_file.WriteEndElement();
_file.WriteEndElement();
}
protected override void ProcessGazeEvents()
{
const int maxIterations = 20;
var gazeData = _latestGazeData;
for (int i = 0; i < maxIterations; i++)
{
var originalGaze = _originalGazeData.Next;
// Queue empty
if (originalGaze == null)
{
break;
}
#if USE_OPENVR_BINDINGS
var now = EyeTrackingOperations.GetSystemTimeStamp();
var backInTime = (originalGaze.SystemTimeStamp - now) / 1000000.0f;
// Look up OpenVR pose back when the eyetracker looked at the eyes.
OpenVR.System.GetDeviceToAbsoluteTrackingPose(OpenVR.Compositor.GetTrackingSpace(), backInTime, poseArray);
if (!poseArray[OpenVR.k_unTrackedDeviceIndex_Hmd].bPoseIsValid)
{
Debug.Log("Failed to get historical pose");
continue;
}
var bestMatchingPose = HMDPoseToETPose(poseArray[OpenVR.k_unTrackedDeviceIndex_Hmd].mDeviceToAbsoluteTracking, now);
#else
var bestMatchingPose = _eyeTrackerOriginPoses.GetBestMatchingPose(originalGaze.SystemTimeStamp);
if (!bestMatchingPose.Valid)
{
Debug.Log("Did not find a matching pose");
continue;
}
#endif
gazeData = new VRGazeData(originalGaze, bestMatchingPose);
_gazeDataQueue.Next = gazeData;
}
var queueCount = UnprocessedGazeDataCount;
if (queueCount > 0)
{
Debug.LogWarning("We didn't manage to empty the queue: " + queueCount + " items left...");
}
_latestGazeData = gazeData;
}
// Update is called once per frame
void Update()
{
VREyeTracker _tobiiEyeTracker = VREyeTracker.Instance;
if (_tobiiEyeTracker != null)
{
IVRGazeData last_ivrGazeData = _tobiiEyeTracker.LatestGazeData;
// set SaveInfo dic
_additionalInfoToSave.SaveInfo = new Dictionary <string, Dictionary <string, string> > {
};
// Timestamp
_additionalInfoToSave.SaveInfo.AddToNestedDictionary("Time", "DeviceTimeStamp", last_ivrGazeData.OriginalGaze.DeviceTimeStamp.ToString());
_additionalInfoToSave.SaveInfo.AddToNestedDictionary("Time", "SystemTimeStamp", last_ivrGazeData.OriginalGaze.SystemTimeStamp.ToString());
// Head
_additionalInfoToSave.SaveInfo.AddToNestedDictionary("Head", "Position_X", last_ivrGazeData.Pose.Position.x.ToString(FORMAT_FLOAT));
_additionalInfoToSave.SaveInfo.AddToNestedDictionary("Head", "Position_Y", last_ivrGazeData.Pose.Position.y.ToString(FORMAT_FLOAT));
_additionalInfoToSave.SaveInfo.AddToNestedDictionary("Head", "Position_Z", last_ivrGazeData.Pose.Position.z.ToString(FORMAT_FLOAT));
_additionalInfoToSave.SaveInfo.AddToNestedDictionary("Head", "Rotation_X", last_ivrGazeData.Pose.Rotation.eulerAngles.x.ToString(FORMAT_FLOAT));
_additionalInfoToSave.SaveInfo.AddToNestedDictionary("Head", "Rotation_Y", last_ivrGazeData.Pose.Rotation.eulerAngles.y.ToString(FORMAT_FLOAT));
_additionalInfoToSave.SaveInfo.AddToNestedDictionary("Head", "Rotation_Z", last_ivrGazeData.Pose.Rotation.eulerAngles.z.ToString(FORMAT_FLOAT));
// combined gaze
_additionalInfoToSave.SaveInfo.AddToNestedDictionary("CombinedGaze", "RayOrigin_X", last_ivrGazeData.CombinedGazeRayWorld.origin.x.ToString(FORMAT_FLOAT));
_additionalInfoToSave.SaveInfo.AddToNestedDictionary("CombinedGaze", "RayOrigin_Y", last_ivrGazeData.CombinedGazeRayWorld.origin.y.ToString(FORMAT_FLOAT));
_additionalInfoToSave.SaveInfo.AddToNestedDictionary("CombinedGaze", "RayOrigin_Z", last_ivrGazeData.CombinedGazeRayWorld.origin.z.ToString(FORMAT_FLOAT));
_additionalInfoToSave.SaveInfo.AddToNestedDictionary("CombinedGaze", "RayDirection_X", last_ivrGazeData.CombinedGazeRayWorld.direction.x.ToString(FORMAT_FLOAT));
_additionalInfoToSave.SaveInfo.AddToNestedDictionary("CombinedGaze", "RayDirection_Y", last_ivrGazeData.CombinedGazeRayWorld.direction.y.ToString(FORMAT_FLOAT));
_additionalInfoToSave.SaveInfo.AddToNestedDictionary("CombinedGaze", "RayDirection_Z", last_ivrGazeData.CombinedGazeRayWorld.direction.z.ToString(FORMAT_FLOAT));
// Eye
// left
WriteTobiiEyeData("LeftEye", last_ivrGazeData.Left);
// right
WriteTobiiEyeData("RightEye", last_ivrGazeData.Right);
}
}
private void WriteGazeData(IVRGazeData gazeData)
{
_file.WriteStartElement("GazeData");
if (_saveUnityData)
{
_file.WriteAttributeString("TimeStamp", gazeData.TimeStamp.ToString());
_file.HMDWritePose(gazeData.Pose);
_file.HMDWriteEye(gazeData.Left, "Left");
_file.HMDWriteEye(gazeData.Right, "Right");
_file.WriteRay(gazeData.CombinedGazeRayWorld, gazeData.CombinedGazeRayWorldValid, "CombinedGazeRayWorld");
}
if (_saveRawData)
{
_file.HMDWriteRawGaze(gazeData.OriginalGaze);
}
_file.WriteEndElement();
}
private void WriteGazeData(IVRGazeData gazeData)
{
_file.WriteStartElement("GazeData");
if (_saveUnityData)
{
String currentTime = System.DateTime.Now.ToString("MM/dd HH:mm:ss.fffff");
_file.WriteAttributeString("TimeStamp", gazeData.TimeStamp.ToString());
_file.WriteAttributeString("MyCustomStamp", currentTime);
_file.HMDWritePose(gazeData.Pose);
_file.HMDWriteEye(gazeData.Left, "Left");
_file.HMDWriteEye(gazeData.Right, "Right");
_file.WriteRay(gazeData.CombinedGazeRayWorld, gazeData.CombinedGazeRayWorldValid, "CombinedGazeRayWorld");
}
if (_saveRawData)
{
_file.HMDWriteRawGaze(gazeData.OriginalGaze);
}
_file.WriteEndElement();
}
public string LatestDataString()
{
IVRGazeData data = LatestEyesData;
string gazedName = (Target.LatestHitObject == null) ? "" : Target.LatestHitObject.name;
Vector3 gazedPoint = Target.LatestHitPoint;
string output = "";
//Get Head
output += string.Format("{0},{1},{2},{3},{4},{5},", Head.position.x.ToString("F4"), Head.position.y.ToString("F4"), Head.position.z.ToString("F4"), Head.eulerAngles.x.ToString("F4"), Head.eulerAngles.y.ToString("F4"), Head.eulerAngles.z.ToString("F4"));
//Get Pose.
if (data.Pose.Valid)
{
output += string.Format("{0},{1},{2},{3},{4},{5},{6},", data.Pose.Position.x.ToString("F4"), data.Pose.Position.y.ToString("F4"), data.Pose.Position.z.ToString("F4"), data.Pose.Rotation.eulerAngles.x.ToString("F4"), data.Pose.Rotation.eulerAngles.y.ToString("F4"), data.Pose.Rotation.eulerAngles.z.ToString("F4"), (data.Pose.Valid ? 1 : 0).ToString());
}
else
{
output += (",,,,,," + (data.Pose.Valid ? 1 : 0).ToString() + ",");
}
//Get Gaze and Gazed Object.
if (data.CombinedGazeRayWorldValid)
{
output += string.Format("{0},{1},{2},{3},{4},{5},{6},{7},{8},{9},{10},{11},{12},{13},{14},{15},{16},{17},{18},{19},{20},{21},{22},",
data.Left.GazeOrigin.x.ToString("F4"),
data.Left.GazeOrigin.y.ToString("F4"),
data.Left.GazeOrigin.z.ToString("F4"),
data.Left.GazeDirection.x.ToString("F4"),
data.Left.GazeDirection.y.ToString("F4"),
data.Left.GazeDirection.z.ToString("F4"),
data.Right.GazeOrigin.x.ToString("F4"),
data.Right.GazeOrigin.y.ToString("F4"),
data.Right.GazeOrigin.z.ToString("F4"),
data.Right.GazeDirection.x.ToString("F4"),
data.Right.GazeDirection.y.ToString("F4"),
data.Right.GazeDirection.z.ToString("F4"),
data.CombinedGazeRayWorld.origin.x.ToString("F4"),
data.CombinedGazeRayWorld.origin.y.ToString("F4"),
data.CombinedGazeRayWorld.origin.z.ToString("F4"),
data.CombinedGazeRayWorld.direction.x.ToString("F4"),
data.CombinedGazeRayWorld.direction.y.ToString("F4"),
data.CombinedGazeRayWorld.direction.z.ToString("F4"),
(data.CombinedGazeRayWorldValid ? 1 : 0).ToString(),
gazedName,
gazedPoint.x.ToString("F4"),
gazedPoint.y.ToString("F4"),
gazedPoint.z.ToString("F4"));
}
else
{
output += string.Format("{0},{1},{2},{3},{4},{5},{6},{7},{8},{9},{10},{11},{12},{13},{14},{15},{16},{17},{18},{19},{20},{21},{22},",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
(data.CombinedGazeRayWorldValid ? 1 : 0).ToString(),
"",
"",
"",
"");
}
output += data.TimeStamp.ToString("F4");
return(output);
}
string FormatInputToCsv(IVRGazeData input)
{
//Debug.Log("erroooooooooooooors" + pm.getErrors());
//Vector3 headDirection = input.Pose.Rotation * Vector3.forward;
//headDirection.normalized.x,
//headDirection.normalized.y,
//headDirection.normalized.z,
//Debug.Log(input.Left.PupilDiameter);
/* string line = string.Format(
* "{0},{1}",
* (Time.unscaledTime - recordingStart).ToString(),
* input.TimeStamp.ToString()
* );
* return line;*/
string line = string.Format(
"{0},{1},{2},{3},{4},{5},{6},{7},{8},{9},{10}," +
"{11},{12},{13},{14},{15},{16},{17},{18},{19},{20},{21},{22},{23},{24},{25}," +
"{26},{27},{28},{29},{30},{31},{32},{33},{34},{35},{36},{37},{38},{39},{40},{41},{42},{43}," +
"{44},{45},{46},{47},{48},{49},{50},{51},{52},{53},{54},{55},{56},{57},{58},{59},{60},{61},{62}",
(Time.unscaledTime - recordingStart).ToString(),
input.TimeStamp.ToString(),
// global elements for hand movements
// dominanthand global rotation x - z
GameObject.FindGameObjectWithTag("Right").transform.rotation.x,
GameObject.FindGameObjectWithTag("Right").transform.rotation.y,
GameObject.FindGameObjectWithTag("Right").transform.rotation.z,
// dominanthand position x - z
GameObject.FindGameObjectWithTag("Right").transform.position.x,
GameObject.FindGameObjectWithTag("Right").transform.position.y,
GameObject.FindGameObjectWithTag("Right").transform.position.z,
// non-dominanthand rotation x - z
GameObject.FindGameObjectWithTag("Left").transform.rotation.x,
GameObject.FindGameObjectWithTag("Left").transform.rotation.y,
GameObject.FindGameObjectWithTag("Left").transform.rotation.z,
// non-dominanthand position x - z
GameObject.FindGameObjectWithTag("Left").transform.position.x,
GameObject.FindGameObjectWithTag("Left").transform.position.y,
GameObject.FindGameObjectWithTag("Left").transform.position.z,
// local elements for hand movements (can get calculated from the camera)
// dominanthand local rotation x - z
GameObject.FindGameObjectWithTag("Right").transform.localRotation.x,
GameObject.FindGameObjectWithTag("Right").transform.localRotation.y,
GameObject.FindGameObjectWithTag("Right").transform.localRotation.z,
// dominanthand position x - z
GameObject.FindGameObjectWithTag("Right").transform.localPosition.x,
GameObject.FindGameObjectWithTag("Right").transform.localPosition.y,
GameObject.FindGameObjectWithTag("Right").transform.localPosition.z,
// non-dominanthand rotation x - z
GameObject.FindGameObjectWithTag("Left").transform.localRotation.x,
GameObject.FindGameObjectWithTag("Left").transform.localRotation.y,
GameObject.FindGameObjectWithTag("Left").transform.localRotation.z,
// non-dominanthand position x - z
GameObject.FindGameObjectWithTag("Left").transform.localPosition.x,
GameObject.FindGameObjectWithTag("Left").transform.localPosition.y,
GameObject.FindGameObjectWithTag("Left").transform.localPosition.z,
// camera (fov) information
Camera.main.transform.rotation.x,
Camera.main.transform.rotation.y,
Camera.main.transform.rotation.z,
Camera.main.transform.position.x,
Camera.main.transform.position.y,
Camera.main.transform.position.z,
input.Pose.Rotation.x,
input.Pose.Rotation.y,
input.Pose.Rotation.z,
input.Pose.Position.x,
input.Pose.Position.y,
input.Pose.Position.z,
input.Left.GazeOrigin.x,
input.Left.GazeOrigin.y,
input.Left.GazeOrigin.z,
input.Right.GazeOrigin.x,
input.Right.GazeOrigin.y,
input.Right.GazeOrigin.z,
input.Left.GazeDirection.x,
input.Left.GazeDirection.y,
input.Left.GazeDirection.z,
input.Right.GazeDirection.x,
input.Right.GazeDirection.y,
input.Right.GazeDirection.z,
input.CombinedGazeRayWorld.direction.normalized.x,
input.CombinedGazeRayWorld.direction.normalized.y,
input.CombinedGazeRayWorld.direction.normalized.z,
input.CombinedGazeRayWorld.origin.x,
input.CombinedGazeRayWorld.origin.y,
input.CombinedGazeRayWorld.origin.z,
input.Left.PupilDiameter,
input.Right.PupilDiameter,
input.Left.PupilPosiitionInTrackingArea.x, // tobii sdk fix Grant [Tobii]
input.Left.PupilPosiitionInTrackingArea.y,
input.Right.PupilPosiitionInTrackingArea.x,
input.Right.PupilPosiitionInTrackingArea.y,
//todo input data, class communication/singleton?
//pm.getErrors(),
//pm.getErrorPos()[0],
// pm.getErrorPos()[1],
////pm.getErrorPos()[2],
//pm.getErrorPos()[3],
pm.getUserInput()
//GameObject.Find("Triggers").GetComponent<SelectionController>().getStatusTriggerRight()
);
return(line);
}
void WriteToFileCsv(IVRGazeData input)
{
//Debug.Log("wirting to file");
sw.WriteLine(FormatInputToCsv(input));
}
// Update is called once per frame
void Update()
{
if (CalibrationInProgress || _eyeTracker.LatestGazeData.CombinedGazeRayWorldValid != true)
{
// Don't do anything if we are calibrating.
if (output_ray != null)
{
output_ray._ray_raw = default(Ray);
}
return;
}
if (HasEyeTracker)
{
switch (datatype)
{
case OptionsTobiiData.NextData:
last_ivrGazeData = _eyeTracker.NextData;
break;
case OptionsTobiiData.LatestGazeData:
last_ivrGazeData = _eyeTracker.LatestGazeData;
break;
case OptionsTobiiData.LatestProcessedGazeData:
last_ivrGazeData = _eyeTracker.LatestProcessedGazeData;
break;
default:
last_ivrGazeData = _eyeTracker.LatestGazeData;
break;
}
if (output_ray != null)
{
switch (eye)
{
case (OptionsAsRay.Combined_Gaze):
output_ray._ray_raw = last_ivrGazeData.CombinedGazeRayWorld;
break;
case (OptionsAsRay.Left_Gaze):
output_ray._ray_raw = last_ivrGazeData.Left.GazeRayWorld;
break;
case (OptionsAsRay.Right_Gaze):
output_ray._ray_raw = last_ivrGazeData.Right.GazeRayWorld;
break;
}
}
}
}
//Return the average pupil diameter in meters.
private float AveragePupilDiameter(IVRGazeData igd)
{
return((igd.Right.PupilDiameter + igd.Left.PupilDiameter) / 2f * 1000f);
}
//Return whether the pupil data is valid.
private bool IsPupilDataValid(IVRGazeData igd)
{
return(igd.Left.PupilDiameterValid && igd.Right.PupilDiameterValid);
}
