public void EnableTracking()
{
if (m_trackingEnabled)
{
return;
}
m_trackingEnabled = true;
Initialize();
m_inputDeviceSN.text = string.Empty;
CheckInputDeviceSN(string.Empty);
for (uint deviceIndex = 0, imax = VRModule.GetDeviceStateCount(); deviceIndex < imax; ++deviceIndex)
{
if (VRModule.GetCurrentDeviceState(deviceIndex).isConnected)
{
OnDeviceConnected(deviceIndex, true);
}
}
VRModule.onDeviceConnected += OnDeviceConnected;
}
private void MappingLeftRightHands()
{
// assign left/right controllers according to the hint
var rightIndex = VRModule.GetRightControllerDeviceIndex();
var leftIndex = VRModule.GetLeftControllerDeviceIndex();
if (VRModule.GetCurrentDeviceState(rightIndex).isConnected)
{
MappingRoleIfUnbound(HandRole.RightHand, rightIndex);
rightIndex = RoleMap.GetMappedDeviceByRole(HandRole.RightHand);
}
else if (RoleMap.IsRoleBound(HandRole.RightHand))
{
rightIndex = RoleMap.GetMappedDeviceByRole(HandRole.RightHand);
}
else
{
rightIndex = VRModule.INVALID_DEVICE_INDEX;
}
if (VRModule.GetCurrentDeviceState(leftIndex).isConnected&& leftIndex != rightIndex)
{
MappingRoleIfUnbound(HandRole.LeftHand, leftIndex);
leftIndex = RoleMap.GetMappedDeviceByRole(HandRole.LeftHand);
}
else if (RoleMap.IsRoleBound(HandRole.LeftHand))
{
leftIndex = RoleMap.GetMappedDeviceByRole(HandRole.LeftHand);
}
else
{
leftIndex = VRModule.INVALID_DEVICE_INDEX;
}
// if not both left/right controllers are assigned, find and assign them with left/right most controller
if (!VRModule.IsValidDeviceIndex(rightIndex) || !VRModule.IsValidDeviceIndex(leftIndex))
{
// find right to left sorted controllers
// FIXME: GetSortedTrackedDeviceIndicesOfClass doesn't return correct devices count right after device connected
#if __VIU_STEAMVR
if (VRModule.activeModule == SupportedVRModule.SteamVR)
{
var count = 0;
var system = Valve.VR.OpenVR.System;
if (system != null)
{
count = (int)system.GetSortedTrackedDeviceIndicesOfClass(Valve.VR.ETrackedDeviceClass.Controller, m_sortedDevices, Valve.VR.OpenVR.k_unTrackedDeviceIndex_Hmd);
}
foreach (var deviceIndex in m_sortedDevices)
{
if (m_sortedDeviceList.Count >= count)
{
break;
}
if (IsController(deviceIndex) && deviceIndex != rightIndex && deviceIndex != leftIndex && !RoleMap.IsDeviceConnectedAndBound(deviceIndex))
{
m_sortedDeviceList.Add(deviceIndex);
}
}
}
else
#endif
{
for (uint deviceIndex = 1u, imax = VRModule.GetDeviceStateCount(); deviceIndex < imax; ++deviceIndex)
{
if (IsController(deviceIndex) && deviceIndex != rightIndex && deviceIndex != leftIndex && !RoleMap.IsDeviceConnectedAndBound(deviceIndex))
{
m_sortedDeviceList.Add(deviceIndex);
}
}
if (m_sortedDeviceList.Count > 1)
{
SortDeviceIndicesByDirection(m_sortedDeviceList, VRModule.GetCurrentDeviceState(VRModule.HMD_DEVICE_INDEX).pose);
}
}
if (m_sortedDeviceList.Count > 0 && !VRModule.IsValidDeviceIndex(rightIndex))
{
rightIndex = m_sortedDeviceList[0];
m_sortedDeviceList.RemoveAt(0);
// mapping right most controller
MappingRole(HandRole.RightHand, rightIndex);
}
if (m_sortedDeviceList.Count > 0 && !VRModule.IsValidDeviceIndex(leftIndex))
{
leftIndex = m_sortedDeviceList[m_sortedDeviceList.Count - 1];
// mapping left most controller
MappingRole(HandRole.LeftHand, leftIndex);
}
m_sortedDeviceList.Clear();
}
if (!VRModule.IsValidDeviceIndex(rightIndex))
{
UnmappingRole(HandRole.RightHand);
}
if (!VRModule.IsValidDeviceIndex(leftIndex))
{
UnmappingRole(HandRole.LeftHand);
}
}
public void Refresh()
{
// find right/left controller index
var rightIndex = VRModule.INVALID_DEVICE_INDEX;
var leftIndex = VRModule.INVALID_DEVICE_INDEX;
if (RoleMap.IsRoleValueBound((int)ControllerRole.RightHand))
{
rightIndex = RoleMap.GetMappedDeviceByRoleValue((int)ControllerRole.RightHand);
}
else
{
var index = VRModule.GetRightControllerDeviceIndex();
if (VRModule.GetDeviceState(index).deviceClass == VRModuleDeviceClass.Controller)
{
rightIndex = index;
}
}
if (RoleMap.IsRoleValueBound((int)ControllerRole.LeftHand))
{
leftIndex = RoleMap.GetMappedDeviceByRoleValue((int)ControllerRole.LeftHand);
}
else
{
var index = VRModule.GetRightControllerDeviceIndex();
if (VRModule.GetDeviceState(index).deviceClass == VRModuleDeviceClass.Controller)
{
leftIndex = index;
}
}
if (leftIndex == rightIndex)
{
leftIndex = VRModule.INVALID_DEVICE_INDEX;
}
// find all other unbound controller class devices
for (uint i = 0u, imax = VRModule.GetDeviceStateCount(); i < imax; ++i)
{
if (i == rightIndex)
{
continue;
}
if (i == leftIndex)
{
continue;
}
var device = VRModule.GetDeviceState(i);
if (!device.isConnected)
{
continue;
}
if (device.deviceClass != VRModuleDeviceClass.Controller)
{
continue;
}
if (RoleMap.IsDeviceBound(device.serialNumber))
{
continue;
}
m_sortedDeviceList.Add(i);
}
// if module didn't hint left/right controllers
// find left/right most device in m_sortedDeviceList and assigned to leftIndex/rightIndex
if (m_sortedDeviceList.Count > 0)
{
HandRoleHandler.SortDeviceIndicesByDirection(m_sortedDeviceList, VRModule.GetCurrentDeviceState(VRModule.HMD_DEVICE_INDEX).pose);
if (rightIndex == VRModule.INVALID_DEVICE_INDEX && !RoleMap.IsRoleBound(ControllerRole.RightHand))
{
rightIndex = m_sortedDeviceList[0];
m_sortedDeviceList.RemoveAt(0);
}
if (m_sortedDeviceList.Count > 0 && leftIndex == VRModule.INVALID_DEVICE_INDEX && !RoleMap.IsRoleBound(ControllerRole.RightHand))
{
leftIndex = m_sortedDeviceList[m_sortedDeviceList.Count - 1];
m_sortedDeviceList.RemoveAt(m_sortedDeviceList.Count - 1);
}
}
if (rightIndex != VRModule.INVALID_DEVICE_INDEX)
{
MappingRoleIfUnbound(ControllerRole.RightHand, rightIndex);
}
if (leftIndex != VRModule.INVALID_DEVICE_INDEX)
{
MappingRoleIfUnbound(ControllerRole.LeftHand, leftIndex);
}
if (m_sortedDeviceList.Count > 0)
{
var otherCtrlIndex = -1;
var otherRole = ControllerRole.Controller3 - 1;
while (NextUnmappedSortedDevice(ref otherCtrlIndex) && NextUnmappedRole(ref otherRole))
{
MappingRole(otherRole, m_sortedDeviceList[otherCtrlIndex]);
}
m_sortedDeviceList.Clear();
}
}
public void Refresh()
{
m_sortedDevices.Clear();
UnmappingAll();
MappingRoleIfUnbound(BodyRole.Head, 0u);
// get related poses and record controller/tracker devices
var hmdPose = VivePose.GetPose(0u);
// preserve only y-axis rotation
hmdPose.rot = Quaternion.Euler(0f, hmdPose.rot.eulerAngles.y, 0f);
// move center to half height
hmdPose.pos = Vector3.Scale(hmdPose.pos, new Vector3(1f, 0.5f, 1f));
var halfHeight = hmdPose.pos.y;
var centerPoseInverse = hmdPose.GetInverse();
for (uint i = 1, imax = VRModule.GetDeviceStateCount(); i < imax; ++i)
{
if (!IsTrackingDevice(i))
{
continue;
}
var relatedCenterPos = centerPoseInverse.InverseTransformPoint(VRModule.GetCurrentDeviceState(i).pose.pos);
m_directionPoint[i] = HandRoleHandler.GetDirectionPoint(new Vector2(relatedCenterPos.x, -relatedCenterPos.y));
m_distanceSqr[i] = relatedCenterPos.sqrMagnitude / (halfHeight * halfHeight);
m_sortedDevices.Add(i);
}
if (m_sortedDevices.Count == 0)
{
return;
}
var index = m_sortedDevices.Count - 1; // pointing last index
// find 2 feet, should be most farest 2 devices
m_sortedDevices.Sort(CompareDistance);
if (IsFoot(m_sortedDevices[index]))
{
if (m_sortedDevices.Count <= 1)
{
MappingRoleIfUnbound(BodyRole.RightFoot, m_sortedDevices[index]);
return;
}
if (!IsFoot(m_sortedDevices[index - 1]))
{
// only 1 foot found
MappingRoleIfUnbound(BodyRole.RightFoot, m_sortedDevices[index]);
m_sortedDevices.RemoveAt(index--);
if (index < 0)
{
return;
}
}
else
{
// 2 feet found, determine lef/right foot
if (m_directionPoint[m_sortedDevices[index]] < m_directionPoint[m_sortedDevices[index - 1]])
{
MappingRoleIfUnbound(BodyRole.RightFoot, m_sortedDevices[index]);
MappingRoleIfUnbound(BodyRole.LeftFoot, m_sortedDevices[index - 1]);
}
else
{
MappingRoleIfUnbound(BodyRole.RightFoot, m_sortedDevices[index - 1]);
MappingRoleIfUnbound(BodyRole.LeftFoot, m_sortedDevices[index]);
}
m_sortedDevices.RemoveAt(index--);
m_sortedDevices.RemoveAt(index--);
if (index < 0)
{
return;
}
}
}
// find 2 hands, should be most left and most right device
m_sortedDevices.Sort(CompareDirection);
// right most device as right hand
MappingRoleIfUnbound(BodyRole.RightHand, m_sortedDevices[0]);
if (m_sortedDevices.Count == 1)
{
return;
}
// left most device as left hand
MappingRoleIfUnbound(BodyRole.LeftHand, m_sortedDevices[index]);
if (m_sortedDevices.Count == 2)
{
return;
}
// middle one as hip
MappingRoleIfUnbound(BodyRole.Hip, m_sortedDevices[index / 2]);
}
public void Refresh()
{
// find tracked right/left hand index
var deviceCount = VRModule.GetDeviceStateCount();
var rightIndex = VRModule.INVALID_DEVICE_INDEX;
var leftIndex = VRModule.INVALID_DEVICE_INDEX;
for (uint deviceIndex = 0u; deviceIndex < deviceCount; ++deviceIndex)
{
var deviceState = VRModule.GetDeviceState(deviceIndex);
if (deviceState.isConnected && deviceState.deviceClass == VRModuleDeviceClass.TrackedHand)
{
if (deviceState.deviceModel.IsRight())
{
rightIndex = deviceIndex;
}
else if (deviceState.deviceModel.IsLeft())
{
leftIndex = deviceIndex;
}
}
}
if (!RoleMap.IsRoleMapped(TrackedHandRole.RightHand))
{
if (rightIndex < deviceCount)
{
MappingRoleIfUnbound(TrackedHandRole.RightHand, rightIndex);
}
}
else if (!RoleMap.IsRoleBound(TrackedHandRole.RightHand))
{
if (rightIndex < deviceCount)
{
MappingRoleIfUnbound(TrackedHandRole.RightHand, rightIndex);
}
else
{
UnmappingRole(TrackedHandRole.RightHand);
}
}
if (!RoleMap.IsRoleMapped(TrackedHandRole.LeftHand))
{
if (leftIndex < deviceCount)
{
MappingRoleIfUnbound(TrackedHandRole.LeftHand, leftIndex);
}
}
else if (!RoleMap.IsRoleBound(TrackedHandRole.LeftHand))
{
if (leftIndex < deviceCount)
{
MappingRoleIfUnbound(TrackedHandRole.LeftHand, leftIndex);
}
else
{
UnmappingRole(TrackedHandRole.LeftHand);
}
}
}