public uint GetSortedTrackedDeviceIndicesOfClass(ETrackedDeviceClass eTrackedDeviceClass,uint [] punTrackedDeviceIndexArray,uint unRelativeToTrackedDeviceIndex)
{
uint result = FnTable.GetSortedTrackedDeviceIndicesOfClass(eTrackedDeviceClass,punTrackedDeviceIndexArray,(uint) punTrackedDeviceIndexArray.Length,unRelativeToTrackedDeviceIndex);
return result;
}
internal static extern uint VR_IVRSystem_GetSortedTrackedDeviceIndicesOfClass(IntPtr instancePtr, ETrackedDeviceClass eTrackedDeviceClass, [In, Out] uint[] punTrackedDeviceIndexArray, uint unTrackedDeviceIndexArrayCount, uint unRelativeToTrackedDeviceIndex);
public static IEnumerable<int> DevicesInClass(this CVRSystem hmd, ETrackedDeviceClass devClass)
{
if (hmd == null) throw new ArgumentNullException(nameof(hmd));
return DeviceIndexes.Where(i => hmd.GetTrackedDeviceClass((uint)i) == devClass);
}
public static int GetDeviceIndex(DeviceRelation relation,
ETrackedDeviceClass deviceClass = ETrackedDeviceClass.Controller,
int relativeTo = (int)OpenVR.k_unTrackedDeviceIndex_Hmd) // use -1 for absolute tracking space
{
var invXform = ((uint)relativeTo < OpenVR.k_unMaxTrackedDeviceCount) ?
Input(relativeTo).transform.GetInverse() : SteamVR_Utils.RigidTransform.identity;
var vr = SteamVR.instance;
var result = -1;
var best = -float.MaxValue;
for (int i = 0; i < OpenVR.k_unMaxTrackedDeviceCount; i++)
{
if (i == relativeTo || vr.hmd.GetTrackedDeviceClass((uint)i) != deviceClass)
continue;
var device = Input(i);
if (!device.connected)
continue;
if (relation == DeviceRelation.First)
return i;
float score;
var pos = invXform * device.transform.pos;
if (relation == DeviceRelation.FarthestRight)
{
score = pos.x;
}
else if (relation == DeviceRelation.FarthestLeft)
{
score = -pos.x;
}
else
{
var dir = new Vector3(pos.x, 0.0f, pos.z).normalized;
var dot = Vector3.Dot(dir, Vector3.forward);
var cross = Vector3.Cross(dir, Vector3.forward);
if (relation == DeviceRelation.Leftmost)
{
score = (cross.y > 0.0f) ? 2.0f - dot : dot;
}
else
{
score = (cross.y < 0.0f) ? 2.0f - dot : dot;
}
}
if (score > best)
{
result = i;
best = score;
}
}
return result;
}
// Token: 0x06001EE5 RID: 7909 RVA: 0x0009C9B6 File Offset: 0x0009ABB6
public uint GetSortedTrackedDeviceIndicesOfClass(ETrackedDeviceClass eTrackedDeviceClass, uint[] punTrackedDeviceIndexArray, uint unRelativeToTrackedDeviceIndex)
{
return(this.FnTable.GetSortedTrackedDeviceIndicesOfClass(eTrackedDeviceClass, punTrackedDeviceIndexArray, (uint)punTrackedDeviceIndexArray.Length, unRelativeToTrackedDeviceIndex));
}
/// <summary>
/// Sets the chosen device as the anchor object, and enables/disables scene objects appropriately.
/// Called by ChooseTrackedObjectMenu when the user clicks it.
/// </summary>
/// <param name="deviceindex">Index of the tracked object.</param>
private void OnTrackedObjectSelected(int deviceindex)
{
//Make sure it's valid.
ZEDControllerTracker.Devices trackeddevice = ZEDControllerTracker.Devices.Hmd; //Can't be HMD at end - will catch.
#if ZED_STEAM_VR
ETrackedDeviceClass dclass = OpenVR.System.GetTrackedDeviceClass((uint)deviceindex);
if (dclass == ETrackedDeviceClass.GenericTracker)
{
trackeddevice = ZEDControllerTracker.Devices.ViveTracker;
}
else if (dclass == ETrackedDeviceClass.Controller)
{
ETrackedControllerRole role = OpenVR.System.GetControllerRoleForTrackedDeviceIndex((uint)deviceindex);
if (role == ETrackedControllerRole.LeftHand)
{
trackeddevice = ZEDControllerTracker.Devices.LeftController;
}
else if (role == ETrackedControllerRole.RightHand)
{
trackeddevice = ZEDControllerTracker.Devices.RightController;
}
else
{
Debug.Log("Couldn't assign to device of index " + deviceindex + " as it's a controller with an unknown role.");
}
//TODO: Make sure this works for a third controller.
}
#endif
#if ZED_OCULUS
if (deviceindex == TOUCH_INDEX_LEFT)
{
trackeddevice = ZEDControllerTracker.Devices.LeftController;
}
else if (deviceindex == TOUCH_INDEX_RIGHT)
{
trackeddevice = ZEDControllerTracker.Devices.RightController;
}
#endif
//Set up the anchor object, and readjust controllers if needed.
zedAnchor.gameObject.SetActive(true);
zedAnchor.controllerTracker.deviceToTrack = trackeddevice;
#if ZED_STEAM_VR
leftController.index = tempLeftController.index;
#endif
switch (trackeddevice)
{
#if ZED_STEAM_VR
case ZEDControllerTracker.Devices.ViveTracker:
leftController.index = tempLeftController.index;
leftController.gameObject.SetActive(true);
break;
#endif
case ZEDControllerTracker.Devices.LeftController:
bellyMenu.gameObject.SetActive(true);
break;
case ZEDControllerTracker.Devices.RightController:
PrimaryHandSwitcher switcher = leftController.GetComponentInChildren <PrimaryHandSwitcher>(true);
if (!switcher)
{
break;
}
ToggleGroup3D handtoggle = switcher.transform.GetComponentInChildren <ToggleGroup3D>(true);
handtoggle.toggleAtStart = false;
leftController.gameObject.SetActive(true);
switcher.SetPrimaryHand(false); //Switch to being left-handed.
Destroy(rightController.gameObject);
rightController = null;
bellyMenu.gameObject.SetActive(true);
break;
case ZEDControllerTracker.Devices.Hmd:
default:
Debug.LogError("trackeddevice value somehow not set to valid value - must be a controller or tracker. ");
break;
}
if (viewScreen)
{
viewScreen.SetActive(true);
}
Destroy(tempLeftController.gameObject);
tempLeftController = null;
//We're all done with this menu, so destroy it all.
Destroy(gameObject);
}
// Update is called once per frame
void Update()
{
Dictionary <ETrackedDeviceClass, List <DeviceInfo> > positions;
if (IsOVRConnected)
{
OpenVRWrapper.Instance.ConvertControllerToTracker = ControlWPFWindow.CurrentSettings.HandleControllerAsTracker;
OpenVRWrapper.Instance.PollingVREvents();
positions = OpenVRWrapper.Instance.GetTrackerPositions();
}
else
{
positions = new Dictionary <ETrackedDeviceClass, List <DeviceInfo> >();
positions.Add(ETrackedDeviceClass.HMD, new List <DeviceInfo>());
positions.Add(ETrackedDeviceClass.Controller, new List <DeviceInfo>());
positions.Add(ETrackedDeviceClass.GenericTracker, new List <DeviceInfo>());
positions.Add(ETrackedDeviceClass.TrackingReference, new List <DeviceInfo>());
}
//externalcamera.cfg用のコントローラー設定
if (CameraControllerName != null && positions.SelectMany(d => d.Value).Any(d => d.serialNumber == CameraControllerName))
{
var cameracontroller = positions.SelectMany(d => d.Value).Where(d => d.serialNumber == CameraControllerName).First();
CameraControllerObject.transform.SetPositionAndRotationLocal(cameracontroller);
foreach (var l in positions)
{
if (l.Value.Contains(cameracontroller))
{
CameraControllerType = l.Key;
l.Value.Remove(cameracontroller);
}
}
}
var hmdPositions = positions[ETrackedDeviceClass.HMD];
if (hmdPositions.Any())
{
HMDObject.transform.SetPositionAndRotationLocal(hmdPositions.FirstOrDefault());
}
var controllerPositions = positions[ETrackedDeviceClass.Controller];
//add from ExternalReceiverForVMC
if (externalReceiver != null)
{
foreach (var c in externalReceiver.virtualControllerFiltered)
{
controllerPositions.Add(new DeviceInfo(c.Value, c.Key));
}
}
if (controllerPositions.Any())
{
if (Controllers.Count != controllerPositions.Count)
{
Controllers.Clear();
}
for (int i = 0; i < controllerPositions.Count && i < ControllersObject.Count; i++)
{
ControllersObject[i].transform.SetPositionAndRotationLocal(controllerPositions[i]);
if (Controllers.Contains(ControllersObject[i]) == false)
{
Controllers.Add(ControllersObject[i]);
}
}
}
else
{
Controllers.Clear(); //残ってしまったものを削除
}
var trackerPositions = positions[ETrackedDeviceClass.GenericTracker];
//add from ExternalReceiverForVMC
if (externalReceiver != null)
{
foreach (var t in externalReceiver.virtualTrackerFiltered)
{
trackerPositions.Add(new DeviceInfo(t.Value, t.Key));
}
}
if (trackerPositions.Any())
{
if (Trackers.Count != trackerPositions.Count)
{
Trackers.Clear();
}
for (int i = 0; i < trackerPositions.Count && i < TrackersObject.Count; i++)
{
TrackersObject[i].transform.SetPositionAndRotationLocal(trackerPositions[i]);
if (Trackers.Contains(TrackersObject[i]) == false)
{
Trackers.Add(TrackersObject[i]);
}
}
}
else
{
Trackers.Clear(); //残ってしまったものを削除
}
var baseStationPositions = positions[ETrackedDeviceClass.TrackingReference];
if (baseStationPositions.Any())
{
if (BaseStations.Count != baseStationPositions.Count)
{
BaseStations.Clear();
}
for (int i = 0; i < baseStationPositions.Count && i < BaseStationsObject.Count; i++)
{
BaseStationsObject[i].transform.SetPositionAndRotationLocal(baseStationPositions[i]);
if (DisableBaseStationRotation)
{
BaseStationsObject[i].transform.rotation = Quaternion.Euler(0, BaseStationsObject[i].transform.eulerAngles.y, 0);
}
if (BaseStations.Contains(BaseStationsObject[i]) == false)
{
BaseStations.Add(BaseStationsObject[i]);
}
}
}
else
{
BaseStations.Clear(); //残ってしまったものを削除
}
}
public int GetDeviceIndex(DeviceRelation relation,
ETrackedDeviceClass deviceClass = ETrackedDeviceClass.Controller,
int relativeTo = (int)OpenVR.k_unTrackedDeviceIndex_Hmd) // use -1 for absolute tracking space
{
var result = -1;
var invXform = ((uint)relativeTo < OpenVR.k_unMaxTrackedDeviceCount)
? Matrix.Invert(Input(relativeTo).WorldTransform) : Matrix.Identity;
var system = OpenVR.System;
if (system == null)
{
return(result);
}
var best = -float.MaxValue;
for (int i = 0; i < OpenVR.k_unMaxTrackedDeviceCount; i++)
{
if (i == relativeTo || system.GetTrackedDeviceClass((uint)i) != deviceClass)
{
continue;
}
var device = Input(i);
if (!device.Connected)
{
continue;
}
if (relation == DeviceRelation.First)
{
return(i);
}
float score;
var pos = Vector3.Transform(device.WorldTransform.Translation, invXform);
if (relation == DeviceRelation.FarthestRight)
{
score = pos.X;
}
else if (relation == DeviceRelation.FarthestLeft)
{
score = -pos.X;
}
else
{
var dir = new Vector3(pos.X, 0.0f, pos.Z);
dir.Normalize();
var dot = Vector3.Dot(dir, Vector3.Forward);
var cross = Vector3.Cross(dir, Vector3.Forward);
if (relation == DeviceRelation.Leftmost)
{
score = (cross.Y > 0.0f) ? 2.0f - dot : dot;
}
else
{
score = (cross.Y < 0.0f) ? 2.0f - dot : dot;
}
}
if (score > best)
{
result = i;
best = score;
}
}
return(result);
}
/// <summary>
/// Scan for available Vive Tracker devices and creates ViveTracker objects accordingly.
/// Init OpenVR if not already done.
/// </summary>
public override void RefreshTrackers()
{
// Delete existing ViveTrackers
foreach (ViveTracker tracker in _trackers)
{
Destroy(tracker.gameObject);
}
_trackers.Clear();
// OVR check
if (!_ovrInit)
{
_ovrInit = _InitOpenVR();
if (!_ovrInit)
{
return;
}
}
Debug.Log("[ViveTrackersManager] Scanning for Tracker devices...");
for (uint i = 0; i < OpenVR.k_unMaxTrackedDeviceCount; ++i)
{
ETrackedDeviceClass deviceClass = _cvrSystem.GetTrackedDeviceClass(i);
if (deviceClass == ETrackedDeviceClass.GenericTracker)
{
string sn = _GetTrackerSerialNumber(i);
if (logTrackersDetection)
{
Debug.Log("[ViveTrackersManager] Tracker detected : " + sn);
}
if (sn != "")
{
string trackerName = "";
bool declared = _declaredTrackers.TryGetValue(sn, out trackerName);
// Creates only trackers declared in config file or all (if !createDeclaredTrackersOnly).
if (declared || !createDeclaredTrackersOnly)
{
ViveTracker vt = GameObject.Instantiate <ViveTracker>(prefab, origin.transform.position, origin.transform.rotation, origin.transform);
vt.Init(new ViveTrackerID(i, sn), declared ? trackerName : sn);
_trackers.Add(vt);
}
}
}
}
// Check
if (_trackers.Count == 0)
{
Debug.LogWarning("[ViveTrackersManager] No trackers available !");
return;
}
// Sort Trackers by name.
_trackers.Sort((ViveTracker x, ViveTracker y) => { return(string.Compare(x.name, y.name)); });
Debug.Log(string.Format("[ViveTrackersManager] {0} trackers declared and {1} trackers available:", _declaredTrackers.Count, _trackers.Count));
foreach (ViveTracker tracker in _trackers)
{
Debug.Log(string.Format("[ViveTrackersManager] -> Tracker : Name = {0} ; SN = {1} ; Index = {2}", tracker.name, tracker.ID.TrackedDevice_SerialNumber, tracker.ID.TrackedDevice_Index));
}
// Fire Action.
if (TrackersFound != null)
{
TrackersFound(_trackers);
}
}
/*
* This should be up and running.
*/
private static void SaveDeviceClass(ETrackedDeviceClass deviceClass, uint index)
{
deviceToIndex[deviceClass].Add(index);
}
// Token: 0x06005EA4 RID: 24228 RVA: 0x002124B4 File Offset: 0x002108B4
public static int GetDeviceIndex(SteamVR_Controller.DeviceRelation relation, ETrackedDeviceClass deviceClass = ETrackedDeviceClass.Controller, int relativeTo = 0)
{
int result = -1;
SteamVR_Utils.RigidTransform t = (relativeTo >= 16) ? SteamVR_Utils.RigidTransform.identity : SteamVR_Controller.Input(relativeTo).transform.GetInverse();
CVRSystem system = OpenVR.System;
if (system == null)
{
return(result);
}
float num = float.MinValue;
int num2 = 0;
while ((long)num2 < 16L)
{
if (num2 != relativeTo && system.GetTrackedDeviceClass((uint)num2) == deviceClass)
{
SteamVR_Controller.Device device = SteamVR_Controller.Input(num2);
if (device.connected)
{
if (relation == SteamVR_Controller.DeviceRelation.First)
{
return(num2);
}
Vector3 vector = t * device.transform.pos;
float num3;
if (relation == SteamVR_Controller.DeviceRelation.FarthestRight)
{
num3 = vector.x;
}
else if (relation == SteamVR_Controller.DeviceRelation.FarthestLeft)
{
num3 = -vector.x;
}
else
{
Vector3 vector2 = new Vector3(vector.x, 0f, vector.z);
Vector3 normalized = vector2.normalized;
float num4 = Vector3.Dot(normalized, Vector3.forward);
Vector3 vector3 = Vector3.Cross(normalized, Vector3.forward);
if (relation == SteamVR_Controller.DeviceRelation.Leftmost)
{
num3 = ((vector3.y <= 0f) ? num4 : (2f - num4));
}
else
{
num3 = ((vector3.y >= 0f) ? num4 : (2f - num4));
}
}
if (num3 > num)
{
result = num2;
num = num3;
}
}
}
num2++;
}
return(result);
}
public void GetDevices(Dictionary <string, TrackedDevice> devices)
{
devices.Clear();
bool changeDetected = false;
_openVRFacade.GetDeviceToAbsoluteTrackingPose(ETrackingUniverseOrigin.TrackingUniverseStanding, _poses);
for (uint i = 0; i < _poses.Length; i++)
{
DeviceUse use = DeviceUse.Unknown;
bool isConnected = _devices[i].isConnected;
string modelName = _devices[i].modelName;
string serialNumber = _devices[i].serialNumber;
ETrackedDeviceClass deviceClass = _openVRFacade.GetTrackedDeviceClass(i);
ETrackedControllerRole controllerRole = _openVRFacade.GetControllerRoleForTrackedDeviceIndex(i);
string role = _openVRFacade.GetStringTrackedDeviceProperty(i, ETrackedDeviceProperty.Prop_ControllerType_String);
if (_poses[i].bDeviceIsConnected != isConnected)
{
isConnected = _poses[i].bDeviceIsConnected;
if (_poses[i].bDeviceIsConnected)
{
modelName = _openVRFacade.GetStringTrackedDeviceProperty(i, ETrackedDeviceProperty.Prop_ModelNumber_String);
serialNumber = _openVRFacade.GetStringTrackedDeviceProperty(i, ETrackedDeviceProperty.Prop_SerialNumber_String);
_logger.Info($"Device '{modelName}' (class '{deviceClass}', serial number '{serialNumber}') connected at index {i}");
}
else
{
_logger.Info($"Device '{modelName}' (class '{deviceClass}', serial number '{serialNumber}') disconnected from index {i}");
modelName = null;
serialNumber = null;
}
changeDetected = true;
}
if (deviceClass != _devices[i].deviceClass)
{
_logger.Trace($"Device '{serialNumber}' class changed from '{_devices[i].deviceClass}' to '{deviceClass}'");
changeDetected = true;
}
if (controllerRole != _devices[i].controllerRole)
{
_logger.Trace($"Device '{serialNumber}' role changed from '{_devices[i].controllerRole}' to '{controllerRole}'");
changeDetected = true;
}
if (role != _devices[i].role)
{
if (role == null)
{
_logger.Trace($"Device '{serialNumber}' role unset from '{_devices[i].role}'");
}
else if (_devices[i].role == null)
{
_logger.Trace($"Device '{serialNumber}' role set to '{role}'");
}
else
{
_logger.Trace($"Device '{serialNumber}' role changed from '{_devices[i].role}' to '{role}'");
}
changeDetected = true;
}
switch (deviceClass)
{
case ETrackedDeviceClass.HMD:
use = DeviceUse.Head;
break;
case ETrackedDeviceClass.Controller:
switch (controllerRole)
{
case ETrackedControllerRole.LeftHand:
use = DeviceUse.LeftHand;
break;
case ETrackedControllerRole.RightHand:
use = DeviceUse.RightHand;
break;
}
break;
case ETrackedDeviceClass.GenericTracker:
switch (role)
{
case "vive_tracker_waist":
use = DeviceUse.Waist;
break;
case "vive_tracker_left_foot":
use = DeviceUse.LeftFoot;
break;
case "vive_tracker_right_foot":
use = DeviceUse.RightFoot;
break;
}
break;
}
bool isTracking = _poses[i].bPoseIsValid && _validTrackingResults.Contains(_poses[i].eTrackingResult);
if (_devices[i].isTracking != isTracking)
{
if (isTracking)
{
_logger.Info($"Acquired tracking of device '{serialNumber}'");
}
else
{
_logger.Info($"Lost tracking of device '{serialNumber}'");
}
changeDetected = true;
}
Vector3 position = Vector3.zero;
Quaternion rotation = Quaternion.identity;
if (isTracking)
{
position = _openVRFacade.GetPosition(_poses[i].mDeviceToAbsoluteTracking);
rotation = _openVRFacade.GetRotation(_poses[i].mDeviceToAbsoluteTracking);
// Driver4VR rotation correction
if (role.StartsWith("d4vr_tracker_") && (use == DeviceUse.LeftFoot || use == DeviceUse.RightFoot))
{
rotation *= Quaternion.Euler(-90, 180, 0);
}
// KinectToVR rotation correction
if (role == "kinect_device")
{
if (use == DeviceUse.Waist)
{
rotation *= Quaternion.Euler(-90, 180, 0);
}
if (use == DeviceUse.LeftFoot || use == DeviceUse.RightFoot)
{
rotation *= Quaternion.Euler(0, 180, 0);
}
}
}
_devices[i] = new OpenVRDevice(isConnected, isTracking, controllerRole, deviceClass, modelName, serialNumber, role);
if (isConnected)
{
devices.Add(serialNumber, new TrackedDevice(serialNumber, use, isTracking, position, rotation));
}
}
if (changeDetected)
{
devicesChanged?.Invoke();
}
}
public OpenVRDevice(bool isConnected, bool isTracking, ETrackedControllerRole controllerRole, ETrackedDeviceClass deviceClass, string modelName, string serialNumber, string role)
{
this.isConnected = isConnected;
this.isTracking = isTracking;
this.controllerRole = controllerRole;
this.deviceClass = deviceClass;
this.modelName = modelName;
this.serialNumber = serialNumber;
this.role = role;
}
public abstract uint GetSortedTrackedDeviceIndicesOfClass(ETrackedDeviceClass eTrackedDeviceClass,uint [] punTrackedDeviceIndexArray,uint unRelativeToTrackedDeviceIndex);
public static int GetDeviceIndex(DeviceRelation relation,
ETrackedDeviceClass deviceClass = ETrackedDeviceClass.Controller,
int relativeTo = (int)OpenVR.k_unTrackedDeviceIndex_Hmd) // use -1 for absolute tracking space
{
var result = -1;
var invXform = ((uint)relativeTo < OpenVR.k_unMaxTrackedDeviceCount) ?
Input(relativeTo).transform.GetInverse() : SteamVR_Utils.RigidTransform.identity;
var system = OpenVR.System;
if (system == null)
{
return(result);
}
var best = -float.MaxValue;
for (int i = 0; i < OpenVR.k_unMaxTrackedDeviceCount; i++)
{
if (i == relativeTo || system.GetTrackedDeviceClass((uint)i) != deviceClass)
{
continue;
}
var device = Input(i);
if (!device.connected)
{
continue;
}
if (relation == DeviceRelation.First)
{
return(i);
}
float score;
var pos = invXform * device.transform.pos;
if (relation == DeviceRelation.FarthestRight)
{
score = pos.x;
}
else if (relation == DeviceRelation.FarthestLeft)
{
score = -pos.x;
}
else
{
var dir = new Vector3(pos.x, 0.0f, pos.z).normalized;
var dot = Vector3.Dot(dir, Vector3.forward);
var cross = Vector3.Cross(dir, Vector3.forward);
if (relation == DeviceRelation.Leftmost)
{
score = (cross.y > 0.0f) ? 2.0f - dot : dot;
}
else
{
score = (cross.y < 0.0f) ? 2.0f - dot : dot;
}
}
if (score > best)
{
result = i;
best = score;
}
}
return(result);
}
public override uint GetSortedTrackedDeviceIndicesOfClass(ETrackedDeviceClass eTrackedDeviceClass,uint [] punTrackedDeviceIndexArray,uint unRelativeToTrackedDeviceIndex)
{
CheckIfUsable();
uint result = VRNativeEntrypoints.VR_IVRSystem_GetSortedTrackedDeviceIndicesOfClass(m_pVRSystem,eTrackedDeviceClass,punTrackedDeviceIndexArray,(uint) punTrackedDeviceIndexArray.Length,unRelativeToTrackedDeviceIndex);
return result;
}
public abstract void OnConnectedDeviceChanged(uint deviceIndex, ETrackedDeviceClass deviceClass, string deviceSN, bool connected);