/// <summary>
/// Update cursor position on canvas based on a ray originating at the VR headset's position and using the headset's forward direction.
/// </summary>
private void TrackHead()
{
Vector3 direction = VRCamera.transform.forward;
Ray ray = new Ray(_rayOrigin, direction);
CurrentHeadGazeScreenPoint = VRCamera.WorldToScreenPoint(_rayOrigin + ray.direction * POINT_CALCULATION_DISTANCE);
HandleHeadRay(ray);
}
public RemoteOutputManager(VRCamera vrCamera, IClient client)
{
this.vrCamera = vrCamera;
this.client = client;
// get client screen resolution
int[] screenResolution = client.readScreenResolution();
Debug.Log("Client screen resolution: " + screenResolution[0] + " x " + screenResolution[1]);
// set vrCamera resolution
vrCamera.textureWidth = screenResolution[0];
vrCamera.textureHeight = screenResolution[1];
}
public override void OnInspectorGUI()
{
DrawDefaultInspector();
VRCamera comp = (VRCamera)target;
bool useLensCorrection = EditorGUILayout.Toggle("Use Lens Correction", comp.useLensCorrection);
float distanceBetweenEyes = EditorGUILayout.FloatField("Distance between eyes", comp.distanceBetweenEyes);
if (GUI.changed)
{
comp.useLensCorrection = useLensCorrection;
comp.distanceBetweenEyes = distanceBetweenEyes;
}
}
/// <summary>
/// 因为投影矩阵相同，只需要设置三个相机的位置一致就可以保持三个画面观看的位置和角度一致
/// </summary>
private void OnEnable()
{
ARCamera.position = VRCamera.position = Camera2D.position;
ScreenCamera3D temp3D;
temp3D = ARCamera.GetComponent <ScreenCamera3D>();
if (temp3D)
{
ARCamera.GetComponent <ScreenCamera3D>().enabled = true;
}
temp3D = VRCamera.GetComponent <ScreenCamera3D>();
if (temp3D)
{
VRCamera.GetComponent <ScreenCamera3D>().enabled = true;
}
}
void Init()
{
if (initialized)
{
return;
}
parentGO = new GameObject();
gameObject.transform.SetParent(parentGO.transform);
gameObject.transform.localRotation = Quaternion.identity;
vrCameraGO = GameObject.FindObjectOfType <VRCamera>();
if (vrCameraGO != null)
{
Canvas cv = gameObject.GetComponentInChildren <Canvas>();
if (cv != null)
{
SetLayerRecursively(cv.gameObject, LayerMask.NameToLayer("TransparentFX"));
cv.renderMode = RenderMode.WorldSpace;
Camera UI_dummyCamera = vrCameraGO.transform.Find("VRCamera/VR_UI_dummyCamera").GetComponent <Camera>();
cv.worldCamera = UI_dummyCamera;
uiCameras = new Camera[vrCameraGO.cameras.Length];
float eyeDist = 0.07f;
float eyeFieldOfView = 100f;
for (int k = 0; k < uiCameras.Length; k++)
{
uiCameras[k] = (Instantiate(vrCameraGO.cameras[k].gameObject, Vector3.zero, Quaternion.identity) as GameObject).GetComponent <Camera>();
foreach (Transform child in uiCameras[k].transform)
{
Destroy(child.gameObject);
}
uiCameras[k].cullingMask = 2;
uiCameras[k].clearFlags = CameraClearFlags.Depth;
uiCameras[k].transform.SetParent(parentGO.transform);
uiCameras[k].transform.localPosition = vrCameraGO.cameras[k].transform.localPosition;
uiCameras[k].transform.localRotation = Quaternion.identity;
eyeDist = Mathf.Abs(uiCameras[k].transform.localPosition.magnitude);
eyeFieldOfView = uiCameras[k].fieldOfView;
uiCameras[k].transform.localRotation = Quaternion.identity;
uiCameras[k].SendMessage("DisableLensCorrection");
if (uiCameras[k].GetComponent <ChangeCameraEye>() != null)
{
uiCameras[k].GetComponent <ChangeCameraEye>().enabled = false;
}
}
float uiDist = 5f * (eyeDist / 0.07f);
transform.localPosition = new Vector3(0f, 0f, uiDist);
RectTransform rt = cv.gameObject.GetComponent <RectTransform>();
rt.localScale = Vector3.one * (2f * scale * uiDist * Mathf.Tan(eyeFieldOfView * 0.5f * Mathf.Deg2Rad)) / rt.rect.height;
if (bindType == BindType.FixedInCenter)
{
vrCameraGO.Init();
parentGO.transform.SetParent(vrCameraGO.vrCameraHeading.transform);
parentGO.transform.localPosition = Vector3.zero;
parentGO.transform.localRotation = Quaternion.identity;
}
else if (bindType == BindType.FixedOrientation)
{
vrCameraGO.Init();
parentGO.transform.SetParent(vrCameraGO.vrCameraHeading.transform);
parentGO.transform.localPosition = Vector3.zero;
parentGO.transform.localRotation = Quaternion.identity;
transform.SetParent(vrCameraGO.transform);
transform.rotation = vrCameraGO.vrCameraHeading.transform.rotation;
}
else if (bindType == BindType.AlwaysInViewField)
{
vrCameraGO.Init();
parentGO.transform.SetParent(vrCameraGO.transform);
parentGO.transform.localPosition = Vector3.zero;
parentGO.transform.localRotation = Quaternion.Euler(Vector3.up * vrCameraGO.vrCameraHeading.localRotation.eulerAngles.y);
for (int k = 0; k < uiCameras.Length; k++)
{
uiCameras[k].transform.SetParent(vrCameraGO.vrCameraHeading.transform);
uiCameras[k].transform.localRotation = Quaternion.identity;
}
fieldViewAngle = Mathf.Atan(cv.pixelRect.width * rt.localScale.x * 0.5f / uiDist) * Mathf.Rad2Deg * 1.2f;
}
}
}
initialized = true;
}
/// <summary>
/// Update cursor position on screen based on the eye gaze ray from VRHMD (if using eyetracking as control method).
/// This function is also called if RecordGazePosition is true, in which case the ray is still handled but the cursor position is not updated.
/// This is in case we want to record gaze position regardless of using eyetracking as control method.
/// </summary>
private void TrackEyes()
{
List <Vector3> eyeDirections = new List <Vector3>();
switch (TestController.Instance.TestBlockData.SelectedVRHMD)
{
case TestBlock.VRHMD.VIVE:
Vector3 gaze = Pupil.values.GazePoint3D;
//Transform and correct eye-tracking
gaze = (transform.rotation * gaze).normalized;
Vector3 delta = transform.forward.normalized - gaze;
gaze = gaze + delta * 2;
//float eyeConfidence = (Pupil.values.Confidences[0] + Pupil.values.Confidences[1]) / 2.0f;
//if (eyeConfidence > 0.7f)
//{
eyeDirections.Add(gaze);
//}
break;
case TestBlock.VRHMD.FOVE:
FoveInterface.EyeRays rays = _foveInterface.GetGazeRays();
EFVR_Eye eyeClosed = FoveInterface.CheckEyesClosed();
switch (eyeClosed)
{
case (EFVR_Eye.Neither):
eyeDirections.Add(rays.left.direction);
eyeDirections.Add(rays.right.direction);
break;
case (EFVR_Eye.Left):
eyeDirections.Add(rays.right.direction);
break;
case (EFVR_Eye.Right):
eyeDirections.Add(rays.left.direction);
break;
case (EFVR_Eye.Both):
eyeDirections.Add(Vector3.zero);
break;
}
break;
}
Vector3 direction = Vector3.zero;
foreach (Vector3 eyeDirection in eyeDirections)
{
direction += eyeDirection;
}
direction = direction / eyeDirections.Count;
Ray ray = new Ray(_rayOrigin, direction);
ray = GetAverageEyeRay(ray);
CurrentEyeGazeScreenPoint = VRCamera.WorldToScreenPoint(_rayOrigin + ray.direction * POINT_CALCULATION_DISTANCE);
if (CurrentControlMethod == TestBlock.ControlMethod.Eyetracking)
{
HandleRay(ray);
}
else
{
HandleGazeTrackingRay(ray);
}
Debug.DrawRay(ray.origin, ray.direction * 100);
}
