677 lines
30 KiB
C#
677 lines
30 KiB
C#
// Copyright HTC Corporation All Rights Reserved.
|
|
|
|
using UnityEngine.XR.OpenXR;
|
|
using UnityEngine.XR.OpenXR.Features;
|
|
using UnityEngine;
|
|
using System.Runtime.InteropServices;
|
|
using System;
|
|
using AOT;
|
|
|
|
#if UNITY_EDITOR
|
|
using UnityEditor;
|
|
using UnityEditor.XR.OpenXR.Features;
|
|
#endif
|
|
|
|
namespace VIVE.OpenXR.EyeTracker
|
|
{
|
|
#if UNITY_EDITOR
|
|
[OpenXRFeature(UiName = "VIVE XR Eye Tracker (Beta)",
|
|
BuildTargetGroups = new[] { BuildTargetGroup.Android, BuildTargetGroup.Standalone },
|
|
Company = "HTC",
|
|
Desc = "Support the eye tracker extension.",
|
|
DocumentationLink = "..\\Documentation",
|
|
OpenxrExtensionStrings = kOpenxrExtensionString,
|
|
Version = "1.0.0",
|
|
FeatureId = featureId)]
|
|
#endif
|
|
public class ViveEyeTracker : OpenXRFeature
|
|
{
|
|
const string LOG_TAG = "VIVE.OpenXR.Eye.ViveEyeTracker";
|
|
void DEBUG(string msg) { Debug.Log(LOG_TAG + " " + msg); }
|
|
void WARNING(string msg) { Debug.LogWarning(LOG_TAG + " " + msg); }
|
|
void ERROR(string msg) { Debug.LogError(LOG_TAG + " " + msg); }
|
|
|
|
public const string kOpenxrExtensionString = "XR_HTC_eye_tracker";
|
|
|
|
/// <summary>
|
|
/// The feature id string. This is used to give the feature a well known id for reference.
|
|
/// </summary>
|
|
public const string featureId = "vive.openxr.feature.eye.tracker";
|
|
|
|
#region OpenXR Life Cycle
|
|
private bool m_XrInstanceCreated = false;
|
|
private XrInstance m_XrInstance = 0;
|
|
private static IntPtr xrGetInstanceProcAddr_prev;
|
|
private static IntPtr WaitFrame_prev;
|
|
private static XrFrameWaitInfo m_frameWaitInfo;
|
|
private static XrFrameState m_frameState;
|
|
protected override IntPtr HookGetInstanceProcAddr(IntPtr func)
|
|
{
|
|
UnityEngine.Debug.Log("EXT: registering our own xrGetInstanceProcAddr");
|
|
xrGetInstanceProcAddr_prev = func;
|
|
return Marshal.GetFunctionPointerForDelegate(m_intercept_xrWaitFrame_xrGetInstanceProcAddr);
|
|
}
|
|
[MonoPInvokeCallback(typeof(OpenXRHelper.xrGetInstanceProcAddrDelegate))]
|
|
private static XrResult intercept_xrWaitFrame_xrGetInstanceProcAddr(XrInstance instance, string name, out IntPtr function)
|
|
{
|
|
if (xrGetInstanceProcAddr_prev == null || xrGetInstanceProcAddr_prev == IntPtr.Zero)
|
|
{
|
|
UnityEngine.Debug.LogError("xrGetInstanceProcAddr_prev is null");
|
|
function = IntPtr.Zero;
|
|
return XrResult.XR_ERROR_VALIDATION_FAILURE;
|
|
}
|
|
|
|
// Get delegate of old xrGetInstanceProcAddr.
|
|
var xrGetProc = Marshal.GetDelegateForFunctionPointer<OpenXRHelper.xrGetInstanceProcAddrDelegate>(xrGetInstanceProcAddr_prev);
|
|
XrResult result = xrGetProc(instance, name, out function);
|
|
if (name == "xrWaitFrame")
|
|
{
|
|
WaitFrame_prev = function;
|
|
m_intercept_xrWaitFrame = intercepted_xrWaitFrame;
|
|
function = Marshal.GetFunctionPointerForDelegate(m_intercept_xrWaitFrame); ;
|
|
UnityEngine.Debug.Log("Getting xrWaitFrame func");
|
|
}
|
|
|
|
return result;
|
|
|
|
}
|
|
[MonoPInvokeCallback(typeof(OpenXRHelper.xrWaitFrameDelegate))]
|
|
private static int intercepted_xrWaitFrame(ulong session, ref XrFrameWaitInfo frameWaitInfo, ref XrFrameState frameState)
|
|
{
|
|
// Get delegate of prev xrWaitFrame.
|
|
var xrWaitFrame = Marshal.GetDelegateForFunctionPointer<OpenXRHelper.xrWaitFrameDelegate>(WaitFrame_prev);
|
|
int res = xrWaitFrame(session, ref frameWaitInfo, ref frameState);
|
|
m_frameWaitInfo = frameWaitInfo;
|
|
m_frameState = frameState;
|
|
return res;
|
|
}
|
|
/// <summary>
|
|
/// Called when <see href="https://registry.khronos.org/OpenXR/specs/1.0/html/xrspec.html#xrCreateInstance">xrCreateInstance</see> is done.
|
|
/// </summary>
|
|
/// <param name="xrInstance">The created instance.</param>
|
|
/// <returns>True for valid <see cref="XrInstance">XrInstance</see></returns>
|
|
protected override bool OnInstanceCreate(ulong xrInstance)
|
|
{
|
|
if (!OpenXRRuntime.IsExtensionEnabled(kOpenxrExtensionString))
|
|
{
|
|
WARNING("OnInstanceCreate() " + kOpenxrExtensionString + " is NOT enabled.");
|
|
return false;
|
|
}
|
|
|
|
m_XrInstanceCreated = true;
|
|
m_XrInstance = xrInstance;
|
|
DEBUG("OnInstanceCreate() " + m_XrInstance);
|
|
return GetXrFunctionDelegates(m_XrInstance);
|
|
}
|
|
/// <summary>
|
|
/// Called when <see href="https://registry.khronos.org/OpenXR/specs/1.0/html/xrspec.html#xrDestroyInstance">xrDestroyInstance</see> is done.
|
|
/// </summary>
|
|
/// <param name="xrInstance">The instance to destroy.</param>
|
|
protected override void OnInstanceDestroy(ulong xrInstance)
|
|
{
|
|
m_XrInstanceCreated = false;
|
|
m_XrInstance = 0;
|
|
DEBUG("OnInstanceDestroy() " + xrInstance);
|
|
}
|
|
|
|
private XrSystemId m_XrSystemId = 0;
|
|
/// <summary>
|
|
/// Called when the <see cref="XrSystemId">XrSystemId</see> retrieved by <see href="https://registry.khronos.org/OpenXR/specs/1.0/html/xrspec.html#xrGetSystem">xrGetSystem</see> is changed.
|
|
/// </summary>
|
|
/// <param name="xrSystem">The system id.</param>
|
|
protected override void OnSystemChange(ulong xrSystem)
|
|
{
|
|
m_XrSystemId = xrSystem;
|
|
DEBUG("OnSystemChange() " + m_XrSystemId);
|
|
}
|
|
|
|
private bool m_XrSessionCreated = false;
|
|
private XrSession m_XrSession = 0;
|
|
private bool hasEyeTracker = false;
|
|
private XrEyeTrackerHTC m_EyeTracker = 0;
|
|
/// <summary>
|
|
/// Called when <see href="https://registry.khronos.org/OpenXR/specs/1.0/html/xrspec.html#xrCreateSession">xrCreateSession</see> is done.
|
|
/// </summary>
|
|
/// <param name="xrSession">The created session ID.</param>
|
|
protected override void OnSessionCreate(ulong xrSession)
|
|
{
|
|
m_XrSession = xrSession;
|
|
m_XrSessionCreated = true;
|
|
DEBUG("OnSessionCreate() " + m_XrSession);
|
|
|
|
if (CreateEyeTracker()) { DEBUG("OnSessionCreate() m_EyeTracker " + m_EyeTracker); }
|
|
}
|
|
/// <summary>
|
|
/// Called when <see href="https://registry.khronos.org/OpenXR/specs/1.0/html/xrspec.html#xrDestroySession">xrDestroySession</see> is done.
|
|
/// </summary>
|
|
/// <param name="xrSession">The session ID to destroy.</param>
|
|
protected override void OnSessionDestroy(ulong xrSession)
|
|
{
|
|
DEBUG("OnSessionDestroy() " + xrSession);
|
|
|
|
// Eye Tracking is binding with xrSession so we destroy the trackers when xrSession is destroyed.
|
|
DestroyEyeTracker();
|
|
|
|
m_XrSession = 0;
|
|
m_XrSessionCreated = false;
|
|
}
|
|
#endregion
|
|
|
|
#region OpenXR function delegates
|
|
private static readonly OpenXRHelper.xrGetInstanceProcAddrDelegate m_intercept_xrWaitFrame_xrGetInstanceProcAddr
|
|
= new OpenXRHelper.xrGetInstanceProcAddrDelegate(intercept_xrWaitFrame_xrGetInstanceProcAddr);
|
|
private static OpenXRHelper.xrWaitFrameDelegate m_intercept_xrWaitFrame;
|
|
/// xrGetInstanceProcAddr
|
|
OpenXRHelper.xrGetInstanceProcAddrDelegate XrGetInstanceProcAddr;
|
|
|
|
/// xrGetSystemProperties
|
|
OpenXRHelper.xrGetSystemPropertiesDelegate xrGetSystemProperties;
|
|
private XrResult GetSystemProperties(ref XrSystemProperties properties)
|
|
{
|
|
if (!m_XrSessionCreated)
|
|
{
|
|
ERROR("GetSystemProperties() XR_ERROR_SESSION_LOST.");
|
|
return XrResult.XR_ERROR_SESSION_LOST;
|
|
}
|
|
if (!m_XrInstanceCreated)
|
|
{
|
|
ERROR("GetSystemProperties() XR_ERROR_INSTANCE_LOST.");
|
|
return XrResult.XR_ERROR_INSTANCE_LOST;
|
|
}
|
|
|
|
return xrGetSystemProperties(m_XrInstance, m_XrSystemId, ref properties);
|
|
}
|
|
|
|
/// xrDestroySpace
|
|
OpenXRHelper.xrDestroySpaceDelegate xrDestroySpace;
|
|
private XrResult DestroySpace(XrSpace space)
|
|
{
|
|
if (!m_XrSessionCreated)
|
|
{
|
|
ERROR("DestroySpace() XR_ERROR_SESSION_LOST.");
|
|
return XrResult.XR_ERROR_SESSION_LOST;
|
|
}
|
|
if (!m_XrInstanceCreated)
|
|
{
|
|
ERROR("DestroySpace() XR_ERROR_INSTANCE_LOST.");
|
|
return XrResult.XR_ERROR_INSTANCE_LOST;
|
|
}
|
|
|
|
return xrDestroySpace(space);
|
|
}
|
|
|
|
ViveEyeTrackerHelper.xrCreateEyeTrackerHTCDelegate xrCreateEyeTrackerHTC;
|
|
private XrResult CreateEyeTrackerHTC(ref XrEyeTrackerCreateInfoHTC createInfo, out XrEyeTrackerHTC eyeTracker)
|
|
{
|
|
if (!m_XrSessionCreated)
|
|
{
|
|
ERROR("CreateEyeTrackerHTC() XR_ERROR_SESSION_LOST.");
|
|
eyeTracker = 0;
|
|
return XrResult.XR_ERROR_SESSION_LOST;
|
|
}
|
|
if (!m_XrInstanceCreated)
|
|
{
|
|
ERROR("CreateEyeTrackerHTC() XR_ERROR_INSTANCE_LOST.");
|
|
eyeTracker = 0;
|
|
return XrResult.XR_ERROR_INSTANCE_LOST;
|
|
}
|
|
|
|
return xrCreateEyeTrackerHTC(m_XrSession, ref createInfo, out eyeTracker);
|
|
}
|
|
|
|
ViveEyeTrackerHelper.xrDestroyEyeTrackerHTCDelegate xrDestroyEyeTrackerHTC;
|
|
private XrResult DestroyEyeTrackerHTC(XrEyeTrackerHTC eyeTracker)
|
|
{
|
|
if (!m_XrSessionCreated)
|
|
{
|
|
ERROR("DestroyEyeTrackerHTC() XR_ERROR_SESSION_LOST.");
|
|
return XrResult.XR_ERROR_SESSION_LOST;
|
|
}
|
|
if (!m_XrInstanceCreated)
|
|
{
|
|
ERROR("DestroyEyeTrackerHTC() XR_ERROR_INSTANCE_LOST.");
|
|
return XrResult.XR_ERROR_INSTANCE_LOST;
|
|
}
|
|
|
|
return xrDestroyEyeTrackerHTC(eyeTracker);
|
|
}
|
|
|
|
ViveEyeTrackerHelper.xrGetEyeGazeDataHTCDelegate xrGetEyeGazeDataHTC;
|
|
private XrResult GetEyeGazeDataHTC(XrEyeTrackerHTC eyeTracker,ref XrEyeGazeDataInfoHTC gazeInfo, ref XrEyeGazeDataHTC eyeGazes)
|
|
{
|
|
if (!m_XrSessionCreated)
|
|
{
|
|
ERROR("GetEyeGazeDataHTC() XR_ERROR_SESSION_LOST.");
|
|
return XrResult.XR_ERROR_SESSION_LOST;
|
|
}
|
|
if (!m_XrInstanceCreated)
|
|
{
|
|
ERROR("GetEyeGazeDataHTC() XR_ERROR_INSTANCE_LOST.");
|
|
return XrResult.XR_ERROR_INSTANCE_LOST;
|
|
}
|
|
|
|
XrResult res = xrGetEyeGazeDataHTC(eyeTracker,ref gazeInfo,ref eyeGazes);
|
|
return res;
|
|
}
|
|
ViveEyeTrackerHelper.xrGetEyePupilDataHTCDelegate xrGetEyePupilDataHTC;
|
|
|
|
private XrResult GetEyePupilDataHTC(XrEyeTrackerHTC eyeTracker,ref XrEyePupilDataInfoHTC pupilDataInfo,ref XrEyePupilDataHTC pupilData)
|
|
{
|
|
if (!m_XrSessionCreated)
|
|
{
|
|
ERROR("GetEyePupilData() XR_ERROR_SESSION_LOST.");
|
|
return XrResult.XR_ERROR_SESSION_LOST;
|
|
}
|
|
if (!m_XrInstanceCreated)
|
|
{
|
|
ERROR("GetEyePupilData() XR_ERROR_INSTANCE_LOST.");
|
|
return XrResult.XR_ERROR_INSTANCE_LOST;
|
|
}
|
|
return xrGetEyePupilDataHTC(eyeTracker,ref pupilDataInfo, ref pupilData);
|
|
}
|
|
ViveEyeTrackerHelper.xrGetEyeGeometricDataHTC xrGetEyeGeometricDataHTC;
|
|
private XrResult GetEyeGeometricDataHTC(XrEyeTrackerHTC eyeTracker,
|
|
ref XrEyeGeometricDataInfoHTC info,
|
|
ref XrEyeGeometricDataHTC eyeGeometricData)
|
|
{
|
|
if (!m_XrSessionCreated)
|
|
{
|
|
ERROR("GetEyeGeometricData() XR_ERROR_SESSION_LOST.");
|
|
return XrResult.XR_ERROR_SESSION_LOST;
|
|
}
|
|
if (!m_XrInstanceCreated)
|
|
{
|
|
ERROR("GetEyeGeometricData() XR_ERROR_INSTANCE_LOST.");
|
|
return XrResult.XR_ERROR_INSTANCE_LOST;
|
|
}
|
|
return xrGetEyeGeometricDataHTC(eyeTracker,ref info, ref eyeGeometricData);
|
|
}
|
|
|
|
private bool GetXrFunctionDelegates(XrInstance xrInstance)
|
|
{
|
|
/// xrGetInstanceProcAddr
|
|
if (xrGetInstanceProcAddr != null && xrGetInstanceProcAddr != IntPtr.Zero)
|
|
{
|
|
DEBUG("Get function pointer of xrGetInstanceProcAddr.");
|
|
XrGetInstanceProcAddr = Marshal.GetDelegateForFunctionPointer(
|
|
xrGetInstanceProcAddr,
|
|
typeof(OpenXRHelper.xrGetInstanceProcAddrDelegate)) as OpenXRHelper.xrGetInstanceProcAddrDelegate;
|
|
}
|
|
else
|
|
{
|
|
ERROR("xrGetInstanceProcAddr is null");
|
|
return false;
|
|
}
|
|
|
|
IntPtr funcPtr = IntPtr.Zero;
|
|
/// xrGetSystemProperties
|
|
if (XrGetInstanceProcAddr(xrInstance, "xrGetSystemProperties", out funcPtr) == XrResult.XR_SUCCESS)
|
|
{
|
|
if (funcPtr != IntPtr.Zero)
|
|
{
|
|
DEBUG("Get function pointer of xrGetSystemProperties.");
|
|
xrGetSystemProperties = Marshal.GetDelegateForFunctionPointer(
|
|
funcPtr,
|
|
typeof(OpenXRHelper.xrGetSystemPropertiesDelegate)) as OpenXRHelper.xrGetSystemPropertiesDelegate;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
ERROR("xrGetSystemProperties");
|
|
return false;
|
|
}
|
|
/// xrDestroySpace
|
|
if (XrGetInstanceProcAddr(xrInstance, "xrDestroySpace", out funcPtr) == XrResult.XR_SUCCESS)
|
|
{
|
|
if (funcPtr != IntPtr.Zero)
|
|
{
|
|
DEBUG("Get function pointer of xrDestroySpace.");
|
|
xrDestroySpace = Marshal.GetDelegateForFunctionPointer(
|
|
funcPtr,
|
|
typeof(OpenXRHelper.xrDestroySpaceDelegate)) as OpenXRHelper.xrDestroySpaceDelegate;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
ERROR("xrDestroySpace");
|
|
return false;
|
|
}
|
|
|
|
/// xrCreateEyeTrackerHTC
|
|
if (XrGetInstanceProcAddr(xrInstance, "xrCreateEyeTrackerHTC", out funcPtr) == XrResult.XR_SUCCESS)
|
|
{
|
|
if (funcPtr != IntPtr.Zero)
|
|
{
|
|
DEBUG("Get function pointer of xrCreateEyeTrackerHTC.");
|
|
xrCreateEyeTrackerHTC = Marshal.GetDelegateForFunctionPointer(
|
|
funcPtr,
|
|
typeof(ViveEyeTrackerHelper.xrCreateEyeTrackerHTCDelegate)) as ViveEyeTrackerHelper.xrCreateEyeTrackerHTCDelegate;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
ERROR("xrCreateEyeTrackerHTC");
|
|
return false;
|
|
}
|
|
/// xrDestroyEyeTrackerHTC
|
|
if (XrGetInstanceProcAddr(xrInstance, "xrDestroyEyeTrackerHTC", out funcPtr) == XrResult.XR_SUCCESS)
|
|
{
|
|
if (funcPtr != IntPtr.Zero)
|
|
{
|
|
DEBUG("Get function pointer of xrDestroyEyeTrackerHTC.");
|
|
xrDestroyEyeTrackerHTC = Marshal.GetDelegateForFunctionPointer(
|
|
funcPtr,
|
|
typeof(ViveEyeTrackerHelper.xrDestroyEyeTrackerHTCDelegate)) as ViveEyeTrackerHelper.xrDestroyEyeTrackerHTCDelegate;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
ERROR("xrDestroyEyeTrackerHTC");
|
|
return false;
|
|
}
|
|
/// xrGetEyeGazeDataHTC
|
|
if (XrGetInstanceProcAddr(xrInstance, "xrGetEyeGazeDataHTC", out funcPtr) == XrResult.XR_SUCCESS)
|
|
{
|
|
if (funcPtr != IntPtr.Zero)
|
|
{
|
|
DEBUG("Get function pointer of xrGetEyeGazeDataHTC.");
|
|
xrGetEyeGazeDataHTC = Marshal.GetDelegateForFunctionPointer(
|
|
funcPtr,
|
|
typeof(ViveEyeTrackerHelper.xrGetEyeGazeDataHTCDelegate)) as ViveEyeTrackerHelper.xrGetEyeGazeDataHTCDelegate;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
ERROR("xrGetEyeGazeDataHTC");
|
|
return false;
|
|
}
|
|
/// xrGetEyePupilDataHTC
|
|
if (XrGetInstanceProcAddr(xrInstance, "xrGetEyePupilDataHTC", out funcPtr) == XrResult.XR_SUCCESS)
|
|
{
|
|
if (funcPtr != IntPtr.Zero)
|
|
{
|
|
DEBUG("Get function pointer of xrGetEyePupilDataHTC.");
|
|
xrGetEyePupilDataHTC = Marshal.GetDelegateForFunctionPointer(
|
|
funcPtr,
|
|
typeof(ViveEyeTrackerHelper.xrGetEyePupilDataHTCDelegate)) as ViveEyeTrackerHelper.xrGetEyePupilDataHTCDelegate;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
ERROR("xrGetEyePupilDataHTC");
|
|
return false;
|
|
}
|
|
/// xrGetEyeGeometricDataHTC
|
|
if (XrGetInstanceProcAddr(xrInstance, "xrGetEyeGeometricDataHTC", out funcPtr) == XrResult.XR_SUCCESS)
|
|
{
|
|
if (funcPtr != IntPtr.Zero)
|
|
{
|
|
DEBUG("Get function pointer of xrGetEyeGeometricDataHTC.");
|
|
xrGetEyeGeometricDataHTC = Marshal.GetDelegateForFunctionPointer(
|
|
funcPtr,
|
|
typeof(ViveEyeTrackerHelper.xrGetEyeGeometricDataHTC)) as ViveEyeTrackerHelper.xrGetEyeGeometricDataHTC;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
ERROR("xrGetEyeGeometricDataHTC");
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
#endregion
|
|
|
|
XrSystemEyeTrackingPropertiesHTC eyeTrackingSystemProperties;
|
|
XrSystemProperties systemProperties;
|
|
private bool IsEyeTrackingSupported()
|
|
{
|
|
if (!m_XrSessionCreated)
|
|
{
|
|
ERROR("IsEyeTrackingSupported() session is not created.");
|
|
return false;
|
|
}
|
|
|
|
eyeTrackingSystemProperties.type = XrStructureType.XR_TYPE_SYSTEM_EYE_TRACKING_PROPERTIES_HTC;
|
|
systemProperties.type = XrStructureType.XR_TYPE_SYSTEM_PROPERTIES;
|
|
systemProperties.next = Marshal.AllocHGlobal(Marshal.SizeOf(eyeTrackingSystemProperties));
|
|
|
|
long offset = 0;
|
|
if (IntPtr.Size == 4)
|
|
offset = systemProperties.next.ToInt32();
|
|
else
|
|
offset = systemProperties.next.ToInt64();
|
|
|
|
IntPtr sys_eye_tracking_prop_ptr = new IntPtr(offset);
|
|
Marshal.StructureToPtr(eyeTrackingSystemProperties, sys_eye_tracking_prop_ptr, false);
|
|
|
|
if (GetSystemProperties(ref systemProperties) == XrResult.XR_SUCCESS)
|
|
{
|
|
if (IntPtr.Size == 4)
|
|
offset = systemProperties.next.ToInt32();
|
|
else
|
|
offset = systemProperties.next.ToInt64();
|
|
|
|
sys_eye_tracking_prop_ptr = new IntPtr(offset);
|
|
eyeTrackingSystemProperties = (XrSystemEyeTrackingPropertiesHTC)Marshal.PtrToStructure(sys_eye_tracking_prop_ptr, typeof(XrSystemEyeTrackingPropertiesHTC));
|
|
|
|
DEBUG("IsEyeTrackingSupported() XrSystemEyeTrackingPropertiesHTC.supportsEyeTracking: "
|
|
+ eyeTrackingSystemProperties.supportsEyeTracking);
|
|
|
|
return (eyeTrackingSystemProperties.supportsEyeTracking > 0);
|
|
}
|
|
else
|
|
{
|
|
ERROR("IsEyeTrackingSupported() GetSystemProperties failed.");
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
/// <summary>
|
|
/// An application can create an <see cref="XrEyeTrackerHTC">XrEyeTrackerHTC</see> handle using CreateEyeTracker.
|
|
/// </summary>
|
|
/// <param name="createInfo">The <see cref="XrEyeTrackerCreateInfoHTC">XrEyeTrackerCreateInfoHTC</see> used to specify the eye tracker.</param>
|
|
/// <param name="eyeTracker">The returned XrEyeTrackerHTC handle.</param>
|
|
/// <returns>XR_SUCCESS for success.</returns>
|
|
public XrResult CreateEyeTracker(XrEyeTrackerCreateInfoHTC createInfo, out XrEyeTrackerHTC eyeTracker)
|
|
{
|
|
if (hasEyeTracker)
|
|
{
|
|
eyeTracker = m_EyeTracker;
|
|
DEBUG("CreateEyeTracker() m_EyeTracker: " + eyeTracker + " already created before.");
|
|
return XrResult.XR_SUCCESS;
|
|
}
|
|
|
|
if (!IsEyeTrackingSupported())
|
|
{
|
|
ERROR("CreateEyeTracker() is NOT supported.");
|
|
eyeTracker = 0;
|
|
return XrResult.XR_ERROR_VALIDATION_FAILURE;
|
|
}
|
|
|
|
var result = CreateEyeTrackerHTC(ref createInfo, out eyeTracker);
|
|
DEBUG("CreateEyeTracker() " + result + ", eyeTracker: " + eyeTracker);
|
|
|
|
if (result == XrResult.XR_SUCCESS)
|
|
{
|
|
hasEyeTracker = true;
|
|
m_EyeTracker = eyeTracker;
|
|
DEBUG("CreateEyeTracker() m_EyeTracker " + m_EyeTracker);
|
|
}
|
|
return result;
|
|
}
|
|
/// <summary>
|
|
/// An application can create an <see cref="XrEyeTrackerHTC">XrEyeTrackerHTC</see> handle using CreateEyeTracker.
|
|
/// </summary>
|
|
/// <returns>True for success.</returns>
|
|
public bool CreateEyeTracker()
|
|
{
|
|
XrEyeTrackerCreateInfoHTC createInfo = new XrEyeTrackerCreateInfoHTC(
|
|
in_type: XrStructureType.XR_TYPE_EYE_TRACKER_CREATE_INFO_HTC,
|
|
in_next: IntPtr.Zero);
|
|
|
|
var result = CreateEyeTracker(createInfo, out XrEyeTrackerHTC value);
|
|
DEBUG("CreateEyeTracker() " + " tracker: " + value);
|
|
return result == XrResult.XR_SUCCESS;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Releases the eye tracker and the underlying resources when the eye tracking experience is over.
|
|
/// </summary>
|
|
/// <param name="eyeTracker">An XrEyeTrackerHTC previously created by xrCreateEyeTrackerHTC.</param>
|
|
/// <returns>XR_SUCCESS for success.</returns>
|
|
public XrResult DestroyEyeTracker(XrEyeTrackerHTC eyeTracker)
|
|
{
|
|
XrResult result = DestroyEyeTrackerHTC(eyeTracker);
|
|
DEBUG("DestroyEyeTracker() " + eyeTracker + ", result: " + result);
|
|
|
|
return result;
|
|
}
|
|
/// <summary>
|
|
/// Releases the eye tracker and the underlying resources when the eye tracking experience is over.
|
|
/// </summary>
|
|
/// <returns>True for success.</returns>
|
|
public bool DestroyEyeTracker()
|
|
{
|
|
if (!hasEyeTracker)
|
|
{
|
|
DEBUG("DestroyEyeTracker() no " + "tracker.");
|
|
return true;
|
|
}
|
|
|
|
XrResult ret = XrResult.XR_ERROR_VALIDATION_FAILURE;
|
|
|
|
ret = DestroyEyeTracker(m_EyeTracker);
|
|
hasEyeTracker = false;
|
|
m_EyeTracker = 0;
|
|
|
|
return ret == XrResult.XR_SUCCESS;
|
|
}
|
|
|
|
private XrEyeGazeDataHTC m_gazes = new XrEyeGazeDataHTC();// = new XrEyeGazeDataHTC(XrStructureType.XR_TYPE_EYE_GAZE_DATA_HTC, IntPtr.Zero, 0);
|
|
/// <summary>
|
|
/// Retrieves an array of <see cref="XrSingleEyeGazeDataHTC">XrSingleEyeGazeDataHTC</see> containing the returned eye gaze directions.
|
|
/// </summary>
|
|
/// <param name="out_gazes">Output parameter to retrieve an array of <see cref="XrSingleEyeGazeDataHTC">XrSingleEyeGazeDataHTC</see>.</param>
|
|
/// <returns>True for success.</returns>
|
|
public bool GetEyeGazeData(out XrSingleEyeGazeDataHTC[] out_gazes)
|
|
{
|
|
m_gazes.type = XrStructureType.XR_TYPE_EYE_GAZE_DATA_HTC;
|
|
m_gazes.next = IntPtr.Zero;
|
|
m_gazes.time = m_frameState.predictedDisplayTime;
|
|
|
|
out_gazes = m_gazes.gaze;
|
|
XrEyeGazeDataInfoHTC gazeInfo = new XrEyeGazeDataInfoHTC(
|
|
in_type: XrStructureType.XR_TYPE_EYE_GAZE_DATA_INFO_HTC,
|
|
in_next: IntPtr.Zero,
|
|
in_baseSpace: GetCurrentAppSpace(),
|
|
in_time: m_frameState.predictedDisplayTime);
|
|
if (GetEyeGazeData(m_EyeTracker, gazeInfo, out m_gazes) == XrResult.XR_SUCCESS)
|
|
{
|
|
out_gazes = m_gazes.gaze;
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
/// <summary>
|
|
/// Retrieves the <see cref="XrEyeGazeDataHTC">XrEyeGazeDataHTC</see> data of a <see cref="XrEyeTrackerHTC">XrEyeTrackerHTC</see>.
|
|
/// </summary>
|
|
/// <param name="eyeTracker">An <see cref="XrEyeTrackerHTC">XrEyeTrackerHTC</see> previously created by <see cref="ViveEyeTrackerHelper.xrCreateEyeTrackerHTCDelegate">xrCreateEyeTrackerHTC</see>.</param>
|
|
/// <param name="gazeInfo">The information to get eye gaze.</param>
|
|
/// <param name="eyeGazes">Output parameter to retrieve a pointer to <see cref="XrEyeGazeDataHTC">XrEyeGazeDataHTC</see> receiving the returned eye poses.</param>
|
|
/// <returns>XR_SUCCESS for success.</returns>
|
|
public XrResult GetEyeGazeData(XrEyeTrackerHTC eyeTracker, XrEyeGazeDataInfoHTC gazeInfo, out XrEyeGazeDataHTC eyeGazes)
|
|
{
|
|
m_gazes.type = XrStructureType.XR_TYPE_EYE_GAZE_DATA_HTC;
|
|
m_gazes.next = IntPtr.Zero;
|
|
m_gazes.time = m_frameState.predictedDisplayTime;
|
|
eyeGazes = m_gazes;
|
|
XrResult result = XrResult.XR_ERROR_VALIDATION_FAILURE;
|
|
result = GetEyeGazeDataHTC(eyeTracker,ref gazeInfo,ref m_gazes);
|
|
if (result == XrResult.XR_SUCCESS) { eyeGazes = m_gazes; }
|
|
|
|
return result;
|
|
}
|
|
|
|
private XrEyePupilDataHTC m_eyePupilData = new XrEyePupilDataHTC();
|
|
|
|
/// <summary>
|
|
/// Retrieves an array of <see cref="XrSingleEyePupilDataHTC">XrSingleEyePupilDataHTC</see> containing the returned data for user's pupils.
|
|
/// </summary>
|
|
/// <param name="pupilData">Output parameter to retrieve an array of <see cref="XrSingleEyePupilDataHTC">XrSingleEyePupilDataHTC</see>.</param>
|
|
/// <returns>XR_SUCCESS for success.</returns>
|
|
public bool GetEyePupilData(out XrSingleEyePupilDataHTC[] pupilData)
|
|
{
|
|
m_eyePupilData.type = XrStructureType.XR_TYPE_EYE_PUPIL_DATA_HTC;
|
|
m_eyePupilData.next = IntPtr.Zero;
|
|
m_eyePupilData.time = m_frameState.predictedDisplayTime;
|
|
pupilData = m_eyePupilData.pupilData;
|
|
XrEyePupilDataInfoHTC pupilDataInfo = new XrEyePupilDataInfoHTC(
|
|
in_type: XrStructureType.XR_TYPE_EYE_PUPIL_DATA_INFO_HTC,
|
|
in_next: IntPtr.Zero);
|
|
if (GetEyePupilData(m_EyeTracker, pupilDataInfo, out m_eyePupilData) == XrResult.XR_SUCCESS)
|
|
{
|
|
pupilData = m_eyePupilData.pupilData;
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Retrieves the <see cref="XrEyePupilDataHTC">XrEyePupilDataHTC</see> data of a <see cref="XrEyeTrackerHTC">XrEyeTrackerHTC</see>.
|
|
/// </summary>
|
|
/// <param name="eyeTracker">An <see cref="XrEyeTrackerHTC">XrEyeTrackerHTC</see> previously created by <see cref="ViveEyeTrackerHelper.xrCreateEyeTrackerHTCDelegate">xrCreateEyeTrackerHTC</see>.</param>
|
|
/// <param name="pupilDataInfo">The information to get pupil data.</param>
|
|
/// <param name="pupilData">A pointer to <see cref="XrEyePupilDataHTC">XrEyePupilDataHTC</see> returned by the runtime.</param>
|
|
/// <returns>XR_SUCCESS for success.</returns>
|
|
public XrResult GetEyePupilData(XrEyeTrackerHTC eyeTracker, XrEyePupilDataInfoHTC pupilDataInfo, out XrEyePupilDataHTC pupilData)
|
|
{
|
|
m_eyePupilData.type = XrStructureType.XR_TYPE_EYE_PUPIL_DATA_HTC;
|
|
m_eyePupilData.next = IntPtr.Zero;
|
|
m_eyePupilData.time = m_frameState.predictedDisplayTime;
|
|
pupilData = m_eyePupilData;
|
|
XrResult result = XrResult.XR_ERROR_VALIDATION_FAILURE;
|
|
result = GetEyePupilDataHTC(eyeTracker,ref pupilDataInfo, ref m_eyePupilData);
|
|
if (result == XrResult.XR_SUCCESS) { pupilData = m_eyePupilData; }
|
|
return result;
|
|
}
|
|
|
|
private XrEyeGeometricDataHTC m_eyeGeometricData = new XrEyeGeometricDataHTC();//XrStructureType.XR_TYPE_EYE_GEOMETRIC_DATA_HTC, IntPtr.Zero, 0);
|
|
/// <param name="geometricData">Output parameter to retrieve an array of <see cref="XrSingleEyeGeometricDataHTC">XrSingleEyeGeometricDataHTC</see>.</param>
|
|
/// <returns>XR_SUCCESS for success.</returns>
|
|
public bool GetEyeGeometricData(out XrSingleEyeGeometricDataHTC[] geometricData)
|
|
{
|
|
m_eyeGeometricData.type = XrStructureType.XR_TYPE_EYE_GEOMETRIC_DATA_HTC;
|
|
m_eyeGeometricData.next = IntPtr.Zero;
|
|
m_eyeGeometricData.time = m_frameState.predictedDisplayTime;
|
|
geometricData = m_eyeGeometricData.eyeGeometricData;
|
|
XrEyeGeometricDataInfoHTC eyeGeometricDataInfo = new XrEyeGeometricDataInfoHTC(
|
|
in_type: XrStructureType.XR_TYPE_EYE_GEOMETRIC_DATA_INFO_HTC,
|
|
in_next: IntPtr.Zero);
|
|
if (GetEyeGeometricData(m_EyeTracker, eyeGeometricDataInfo, out m_eyeGeometricData) == XrResult.XR_SUCCESS)
|
|
{
|
|
geometricData = m_eyeGeometricData.eyeGeometricData;
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/// <param name="eyeTracker">An <see cref="XrEyeTrackerHTC">XrEyeTrackerHTC</see> previously created by <see cref="ViveEyeTrackerHelper.xrCreateEyeTrackerHTCDelegate">xrCreateEyeTrackerHTC</see>.</param>
|
|
/// <param name="eyeGeometricDataInfo">A pointer to <see cref="XrEyeGeometricDataInfoHTC">XrEyeGeometricDataInfoHTC</see> structure.</param>
|
|
/// <param name="eyeGeometricData">A pointer to <see cref="XrEyeGeometricDataHTC">XrEyeGeometricDataHTC</see> returned by the runtime.</param>
|
|
/// <returns>XR_SUCCESS for success.</returns>
|
|
public XrResult GetEyeGeometricData(XrEyeTrackerHTC eyeTracker, XrEyeGeometricDataInfoHTC eyeGeometricDataInfo, out XrEyeGeometricDataHTC eyeGeometricData)
|
|
{
|
|
m_eyeGeometricData.type = XrStructureType.XR_TYPE_EYE_GEOMETRIC_DATA_HTC;
|
|
m_eyeGeometricData.next = IntPtr.Zero;
|
|
m_eyeGeometricData.time = m_frameState.predictedDisplayTime;
|
|
eyeGeometricData = m_eyeGeometricData;
|
|
XrResult result = XrResult.XR_ERROR_VALIDATION_FAILURE;
|
|
result = GetEyeGeometricDataHTC(eyeTracker,ref eyeGeometricDataInfo, ref m_eyeGeometricData);
|
|
if (result == XrResult.XR_SUCCESS) { eyeGeometricData = m_eyeGeometricData; }
|
|
return result;
|
|
}
|
|
}
|
|
}
|