private void CheckLeftOrRightContoller(MessageObject obj)
{
ETrackedControllerRole trackerdRole = ETrackedControllerRole.Invalid;
var system = Valve.VR.OpenVR.System;
if (system != null && null != trackedController)
{
trackerdRole = system.GetControllerRoleForTrackedDeviceIndex(trackedController.controllerIndex);
}
#region use by string name as legacy
#if By_Name_String
controllerType = HandleControllerType.Invalid;
if (this.name.Contains("left"))
{
controllerType = HandleControllerType.LeftHand;
}
if (this.name.Contains("right"))
{
controllerType = HandleControllerType.RightHand;
}
#endif
#endregion
controllerType = (HandleControllerType)((int)trackerdRole);
}
// Token: 0x0600570A RID: 22282 RVA: 0x001DFABC File Offset: 0x001DDEBC
public override void GenerateHapticEvent(VRCTracking.ID id, float duration, float amplitude, float frequency)
{
CVRSystem system = OpenVR.System;
if (system == null)
{
return;
}
ETrackedControllerRole unDeviceType = ETrackedControllerRole.Invalid;
if (id != VRCTracking.ID.HandTracker_LeftWrist)
{
if (id == VRCTracking.ID.HandTracker_RightWrist)
{
unDeviceType = ETrackedControllerRole.RightHand;
}
}
else
{
unDeviceType = ETrackedControllerRole.LeftHand;
}
VRCTrackingTouch.HapticWave hapticWave = default(VRCTrackingTouch.HapticWave);
hapticWave.controllerIndex = system.GetTrackedDeviceIndexForControllerRole(unDeviceType);
hapticWave.duration = duration;
hapticWave.strength = Mathf.Clamp01(amplitude);
hapticWave.frequency = frequency;
if (this.currentHapticLoop[(int)((UIntPtr)hapticWave.controllerIndex)] != null)
{
base.StopCoroutine(this.currentHapticLoop[(int)((UIntPtr)hapticWave.controllerIndex)]);
}
this.currentHapticLoop[(int)((UIntPtr)hapticWave.controllerIndex)] = base.StartCoroutine("HapticLoop", hapticWave);
}
private void ReportControllerFound(ETrackedControllerRole role, uint index)
{
switch (role)
{
case ETrackedControllerRole.LeftHand:
if (!_alreadyFoundLeft)
{
Log("Found Controller ( Device: {0} ): Left", index);
}
_alreadyFoundLeft = true;
break;
case ETrackedControllerRole.RightHand:
if (!_alreadyFoundRight)
{
Log("Found Controller ( Device: {0} ): Right", index);
}
_alreadyFoundRight = true;
break;
case ETrackedControllerRole.Invalid:
Log("Found Controller ( Device: {0} ): Unassigned", index);
break;
}
}
private void CallIndexChanged(ETrackedControllerRole role, uint index)
{
if (OnControllerIndexChanged != null)
{
OnControllerIndexChanged(role, index);
}
}
private uint GetControllerId(Chirality chirality)
{
ETrackedControllerRole targetRole = ETrackedControllerRole.Invalid;
if (chirality == Chirality.Left)
{
targetRole = ETrackedControllerRole.LeftHand;
}
if (chirality == Chirality.Right)
{
targetRole = ETrackedControllerRole.RightHand;
}
uint index = 0;
for (int i = 0; i < OpenVR.k_unMaxTrackedDeviceCount; i++)
{
if (OpenVR.System.GetControllerRoleForTrackedDeviceIndex((uint)i) == targetRole)
{
index = (uint)i;
break;
}
}
return(index);
}
public void SetOverlayTransformTrackedDeviceRelative(ETrackedControllerRole Device, HmdMatrix34_t matrix)
{
if (this.Controller != null)
{
OpenVR.Overlay.SetOverlayTransformTrackedDeviceRelative(this.Handle, OpenVR.System.GetTrackedDeviceIndexForControllerRole(Device), ref matrix);
}
}
private void ShowInfo(uint deviceIndex)
{
ETrackedDeviceClass deviceClass = OpenVR.System.GetTrackedDeviceClass(deviceIndex);
ETrackedControllerRole role = GetDeviceRole(deviceIndex);
bool hasbattery = HasBattery(deviceIndex);
bool isCharging = IsCharging(deviceIndex);
Debug.Log($"{this}:#{deviceIndex} {deviceClass}/{role} battery: {hasbattery} charging: {isCharging}", this);
}
public void OnLateUpdate()
{
dispatchOpenVREvents();
EVRCompositorError compositorError = OpenVR.Compositor.WaitGetPoses(VRManager.RenderPoses, VRManager.GamePoses);
if (compositorError != EVRCompositorError.None)
{
throw new Exception("OpenVr error: " + compositorError.ToString());
}
OpenVR.System.GetDeviceToAbsoluteTrackingPose(ETrackingUniverseOrigin.TrackingUniverseStanding, Utils.CalculatePredictedSecondsToPhotons(), VRManager.DevicePoses);
SteamVR_Events.NewPoses.Send(VRManager.DevicePoses);
for (int i = 0; i < VRManager.DevicePoses.Length; i++)
{
TrackedDevicePose_t devicePose = VRManager.DevicePoses[i];
if (!devicePose.bDeviceIsConnected || !devicePose.bPoseIsValid)
{
continue;
}
SteamVR_Utils.RigidTransform rigidTransform = new SteamVR_Utils.RigidTransform(devicePose.mDeviceToAbsoluteTracking);
ETrackedDeviceClass deviceType = OpenVR.System.GetTrackedDeviceClass((uint)i);
if (deviceType == ETrackedDeviceClass.HMD)
{
Head.transform.localPosition = rigidTransform.pos;
Head.transform.localRotation = rigidTransform.rot;
Head.Velocity = fromHmdVector3_t(devicePose.vVelocity);
Head.AngularVelocity = fromHmdVector3_t(devicePose.vAngularVelocity);
Head.DeviceIndex = (uint)i;
}
else if (deviceType == ETrackedDeviceClass.Controller)
{
ETrackedControllerRole role = OpenVR.System.GetControllerRoleForTrackedDeviceIndex((uint)i);
if (role == ETrackedControllerRole.LeftHand)
{
LeftController.transform.localPosition = rigidTransform.pos;
LeftController.transform.localRotation = rigidTransform.rot;
LeftController.Velocity = fromHmdVector3_t(devicePose.vVelocity);
LeftController.AngularVelocity = fromHmdVector3_t(devicePose.vAngularVelocity);
LeftController.DeviceIndex = (uint)i;
}
else if (role == ETrackedControllerRole.RightHand)
{
RightController.transform.localPosition = rigidTransform.pos;
RightController.transform.localRotation = rigidTransform.rot;
RightController.Velocity = fromHmdVector3_t(devicePose.vVelocity);
RightController.AngularVelocity = fromHmdVector3_t(devicePose.vAngularVelocity);
RightController.DeviceIndex = (uint)i;
}
}
}
}
public OpenVRDevice(string id, bool isConnected, bool isTracking, ETrackedControllerRole controllerRole, ETrackedDeviceClass deviceClass, string modelName, string role)
{
this.id = id;
this.isConnected = isConnected;
this.isTracking = isTracking;
this.controllerRole = controllerRole;
this.deviceClass = deviceClass;
this.modelName = modelName;
this.role = role;
}
/// <summary>
/// Creates a button for a tracked object detected in FindTrackedObjects() and sets it up.
/// </summary>
/// <param name="deviceindex">Index of the tracked object.</param>
/// <param name="scriptref">Required ChooseTrackedObjectButton script that must be on the prefab.</param>
private GameObject CreateTrackedObjectPrefab(uint deviceindex, out ChooseTrackedObjectButton scriptref)
{
string label = "ERROR";
#if ZED_STEAM_VR
ETrackedDeviceClass dclass = OpenVR.System.GetTrackedDeviceClass(deviceindex);
ETrackedControllerRole role = OpenVR.System.GetControllerRoleForTrackedDeviceIndex(deviceindex);
if (!(dclass == ETrackedDeviceClass.Controller || dclass == ETrackedDeviceClass.GenericTracker))
{
//Debug.LogError("Tried to create button for tracked device of index " + deviceindex + ", but it's role is " + dclass + ".");
scriptref = null;
return(null);
}
if (role == ETrackedControllerRole.LeftHand)
{
label = "Left\r\nController";
}
else if (role == ETrackedControllerRole.RightHand)
{
label = "Right\r\nController";
}
else if (dclass == ETrackedDeviceClass.GenericTracker)
{
label = "Tracker";
}
else
{
//Debug.LogError("Tried to create button for tracked device of index " + deviceindex + " with an invalid role/device class combo: " +
// role + " / " + dclass);
scriptref = null;
return(null);
}
#elif ZED_OCULUS
if (deviceindex == TOUCH_INDEX_LEFT)
{
label = "Left\r\nController";
}
else if (deviceindex == TOUCH_INDEX_RIGHT)
{
label = "Right\r\nController";
}
#endif
GameObject buttongo = Instantiate(chooseObjectButtonPrefab, transform, false);
scriptref = buttongo.GetComponentInChildren <ChooseTrackedObjectButton>();
scriptref.SetDeviceIndex((int)deviceindex);
scriptref.SetLabel(label);
buttongo.name = "Select " + label + " Button";
scriptref.OnTrackedObjectSelected += OnTrackedObjectSelected;
return(buttongo);
}
private void CheckLeftOrRightContoller(MessageObject obj)
{
ETrackedControllerRole trackerdRole = ETrackedControllerRole.Invalid;
var system = Valve.VR.OpenVR.System;
if (system != null && null != trackedController)
{
trackerdRole = system.GetControllerRoleForTrackedDeviceIndex(trackedController.controllerIndex);
}
controllerType = (HandleControllerType)((int)trackerdRole);
}
// If the controller we are tracking changes index, update
private void OnControllerIndexChanged(ETrackedControllerRole role, uint index)
{
if (Type == EType.LeftController && role == ETrackedControllerRole.LeftHand)
{
Reset();
}
else if (Type == EType.RightController && role == ETrackedControllerRole.RightHand)
{
Reset();
}
}
// If the controller we are tracking changes index, update
private void OnControllerIndexChanged(ETrackedControllerRole role, uint index)
{
if (_anchorDevice == MountDevice.LeftController && role == ETrackedControllerRole.LeftHand)
{
_anchorDevice = MountDevice.World; // This will trick the system into reattaching the overlay
}
else if (_anchorDevice == MountDevice.RightController && role == ETrackedControllerRole.RightHand)
{
_anchorDevice = MountDevice.World; // This will trick the system into reattaching the overlay
}
}
void Update()
{
if (Input.GetKeyDown(mRecalibrateButton))
{
// switch the roles around
myRole = myRole == ETrackedControllerRole.LeftHand ? ETrackedControllerRole.RightHand : ETrackedControllerRole.LeftHand;
// get the new glove index
GetGloveIndex();
}
}
private void DoIndexAssignment(ETrackedControllerRole role, ref uint index, uint newIndex)
{
if (index == newIndex)
{
return;
}
index = newIndex;
if (OnControllerIndexChanged != null)
{
OnControllerIndexChanged(role, index);
}
}
/// <summary>
/// Creates a GameObject that represents the left or right device controllers.
/// These are the "VR hands".
/// </summary>
/// <param name="role">The controller device role (left or right).</param>
/// <returns>The GameObject for the "VR hand".</returns>
protected GameObject CreateManipulator(ETrackedControllerRole role)
{
// create new GameObject
GameObject manipulator = new GameObject("KVR_Manipulator");
DontDestroyOnLoad(manipulator);
// define the Manipulator component
Manipulator manipulatorComponent = manipulator.AddComponent <Manipulator>();
manipulatorComponent.SetRole(role);
return(manipulator);
}
public void TriggerHapticPulse(XRNode node, byte strength)
{
if (strength == 0)
{
return;
}
float pulseDuration = Time.smoothDeltaTime * 1000000.0f;
float biasedStrength = Plugin.SteamBiasTable[Math.Min(9, (int)strength)];
float F = pulseDuration * biasedStrength;
CVRSystem system = OpenVR.System;
ETrackedControllerRole unDeviceType = (node == XRNode.LeftHand) ? ETrackedControllerRole.LeftHand : ETrackedControllerRole.RightHand;
uint trackedDeviceIndexForControllerRole = system.GetTrackedDeviceIndexForControllerRole(unDeviceType);
system.TriggerHapticPulse(trackedDeviceIndexForControllerRole, 0u, (char)F);
}
public void SetRole(ETrackedControllerRole role)
{
if (role != ETrackedControllerRole.LeftHand && role != ETrackedControllerRole.RightHand)
{
throw new ArgumentException("Cannot assign controller role \"" + role.ToString() + "\"");
}
// assign role
this.Role = role;
// ensure glove object is mirrored correctly
Vector3 gloveObjectScale = gloveGameObject.transform.localScale;
if (Role == ETrackedControllerRole.RightHand)
{
gloveObjectScale.y *= -1f;
gloveGameObject.transform.localScale = gloveObjectScale;
}
}
private GameObject CreateManipulator(ETrackedControllerRole role)
{
// create new GameObject
GameObject manipulator = GameObject.CreatePrimitive(PrimitiveType.Sphere);
manipulator.name = "VR_Manipulator_" + role.ToString();
DontDestroyOnLoad(manipulator);
// define the render model
manipulator.transform.localScale = Vector3.one *
((role == ETrackedControllerRole.RightHand) ? 0.02f : 0.08f);
Color manipulatorColor = (role == ETrackedControllerRole.RightHand) ? Color.green : Color.red;
MeshRenderer manipulatorRenderer = manipulator.GetComponent <MeshRenderer>();
manipulatorRenderer.material.color = manipulatorColor;
// define the collider
Rigidbody manipulatorRigidbody = manipulator.AddComponent <Rigidbody>();
manipulatorRigidbody.isKinematic = true;
SphereCollider manipulatorCollider = manipulator.GetComponent <SphereCollider>();
manipulatorCollider.isTrigger = true;
// define the Manipulator component
Manipulator manipulatorComponent = manipulator.AddComponent <Manipulator>();
manipulatorComponent.role = role;
manipulatorComponent.originalColor = manipulatorColor;
manipulatorComponent.activeColor = Color.yellow;
#if DEBUG
manipulatorRenderer.enabled = true;
#else
manipulatorRenderer.enabled = false;
#endif
return(manipulator);
}
/// <summary>
/// Creates a GameObject that represents the left or right device controllers.
/// These are the "VR hands".
/// </summary>
/// <param name="role">The controller device role (left or right).</param>
/// <returns>The GameObject for the "VR hand".</returns>
protected GameObject CreateManipulator(ETrackedControllerRole role)
{
// create new GameObject
GameObject manipulator = new GameObject("KVR_Manipulator_" + role.ToString());
DontDestroyOnLoad(manipulator);
// define the Manipulator component
Manipulator manipulatorComponent = manipulator.AddComponent <Manipulator>();
manipulatorComponent.role = role;
#if DEBUG
GameObject manipulatorGizmo = Utils.CreateGizmo();
manipulatorGizmo.transform.SetParent(manipulator.transform);
manipulatorGizmo.transform.localPosition = Vector3.zero;
manipulatorGizmo.transform.localRotation = Quaternion.identity;
manipulatorGizmo.transform.localScale = Vector3.one * 0.5f;
#endif
return(manipulator);
}
public abstract uint GetTrackedDeviceIndexForControllerRole(ETrackedControllerRole unDeviceType);
public void SetOverlayTransformTrackedDeviceRelative(ETrackedControllerRole Device)
{
SetOverlayTransformTrackedDeviceRelative(Device, identity);
}
private void UpdateInput(HOTK_TrackedDevice device, ref bool clicked, ref float clickTime, ref float doubleClickTime, ref bool touchpadClicked, ref float touchpadTime, ref bool grips, ref float gripsTime, ref bool touchpadTouch, ETrackedControllerRole role)
{
if (device == null || !device.IsValid)
{
return;
}
var svr = SteamVR.instance;
if (svr == null)
{
return;
}
var c = new VRControllerState_t();
svr.hmd.GetControllerState((uint)device.Index, ref c);
// c.rAxis0 is Trackpad
// c.rAxis1 is Trigger
// Trigger check
if (c.rAxis1.x >= 0.99f)
{
if (!clicked)
{
clicked = true;
clickTime = Time.time;
if (OnControllerTriggerDown != null)
{
OnControllerTriggerDown(device);
}
}
}
else
{
if (clicked)
{
clicked = false;
if (OnControllerTriggerUp != null)
{
OnControllerTriggerUp(device);
}
if ((Time.time - doubleClickTime) < 0.25f)
{
if (OnControllerTriggerDoubleClicked != null)
{
OnControllerTriggerDoubleClicked(device);
}
return;
}
doubleClickTime = Time.time;
if (!((Time.time - clickTime) < 0.25f))
{
return;
}
if (OnControllerTriggerClicked != null)
{
OnControllerTriggerClicked(device);
}
}
}
// Touchpad Check
if (GetPress(c, EVRButtonId.k_EButton_SteamVR_Touchpad))
{
if (!touchpadClicked)
{
touchpadClicked = true;
touchpadTime = Time.time;
if (OnControllerTouchpadDown != null)
{
OnControllerTouchpadDown(device);
}
}
}
else
{
if (touchpadClicked)
{
touchpadClicked = false;
if (OnControllerTouchpadUp != null)
{
OnControllerTouchpadUp(device);
}
if (!((Time.time - touchpadTime) < 0.25f))
{
return;
}
if (OnControllerTouchpadClicked != null)
{
OnControllerTouchpadClicked(device);
}
}
}
// Grips Check
if (GetPress(c, EVRButtonId.k_EButton_Grip))
{
if (!grips)
{
grips = true;
gripsTime = Time.time;
if (OnControllerGripsDown != null)
{
OnControllerGripsDown(device);
}
}
}
else
{
if (grips)
{
grips = false;
if (OnControllerGripsUp != null)
{
OnControllerGripsUp(device);
}
if (!((Time.time - gripsTime) < 0.25f))
{
return;
}
if (OnControllerGripsClicked != null)
{
OnControllerGripsClicked(device);
}
}
}
if (c.rAxis0.x != 0f && c.rAxis0.y != 0f)
{
if (!touchpadTouch)
{
touchpadTouch = true;
if (OnControllerTouchpadTouchStart != null)
{
OnControllerTouchpadTouchStart(device, c.rAxis0.x, c.rAxis0.y);
}
}
else if (OnControllerTouchpadTouchMove != null)
{
OnControllerTouchpadTouchMove(device, c.rAxis0.x, c.rAxis0.y);
}
}
else
{
if (touchpadTouch)
{
touchpadTouch = false;
if (OnControllerTouchpadTouchEnd != null)
{
OnControllerTouchpadTouchEnd(device);
}
}
}
}
internal static extern uint VR_IVRSystem_GetTrackedDeviceIndexForControllerRole(IntPtr instancePtr, ETrackedControllerRole unDeviceType);
private static void Worker()
{
Thread.CurrentThread.IsBackground = true;
while (true)
{
// Getting events
var vrEvents = new List <VREvent_t>();
var vrEvent = new VREvent_t();
try
{
while (OpenVR.System.PollNextEvent(ref vrEvent, Utils.SizeOf(vrEvent)))
{
vrEvents.Add(vrEvent);
}
}
catch (Exception e)
{
Utils.PrintWarning($"Could not get evemt: {e.Message}");
}
// Priting events
foreach (var e in vrEvents)
{
var pid = e.data.process.pid;
if ((EVREventType)vrEvent.eventType != EVREventType.VREvent_None)
{
var name = Enum.GetName(typeof(EVREventType), e.eventType);
var message = $"[{pid}] {name}";
if (pid == 0)
{
Utils.PrintVerbose(message);
}
else if (name.ToLower().Contains("fail"))
{
Utils.PrintWarning(message);
}
else if (name.ToLower().Contains("error"))
{
Utils.PrintError(message);
}
else if (name.ToLower().Contains("success"))
{
Utils.PrintInfo(message);
}
else
{
Utils.Print(message);
}
}
}
// Update action set
// Seems I need the action set when updating the state of actions.
var actionSet = new VRActiveActionSet_t();
actionSet.ulActionSet = mActionSetHandle;
var actionSetArr = new VRActiveActionSet_t[1] {
actionSet
};
// But I cannot get the size of an array so I supply the one for the set inside the array.
// No really sure what I am actually supposed to do here (or above).
var errorUAS = OpenVR.Input.UpdateActionState(actionSetArr, Utils.SizeOf(actionSet));
if (errorUAS != EVRInputError.None)
{
Utils.PrintError($"UpdateActionState Error: {Enum.GetName(typeof(EVRInputError), errorUAS)}");
}
// Get input actions
var roles = new ETrackedControllerRole[] { ETrackedControllerRole.LeftHand, ETrackedControllerRole.RightHand };
foreach (var role in roles)
{
// Get device to restrict to, appears mandatory, makes sense for shared actions.
uint index = OpenVR.System.GetTrackedDeviceIndexForControllerRole(role);
// Load action data
var action = new InputDigitalActionData_t(); // I assume this is used for boolean inputs.
var size = Utils.SizeOf(action);
var error = OpenVR.Input.GetDigitalActionData(mActionHandle, ref action, size, index);
// Result
if (error != mLastError)
{
mLastError = error;
Utils.PrintError($"DigitalActionDataError: {Enum.GetName(typeof(EVRInputError), error)}");
}
Debug.WriteLine(action.bActive + " " + action.bChanged);
if (action.bChanged)
{
Utils.PrintInfo($"Action state changed to: {action.bState}");
}
}
// Restrict rate
Thread.Sleep(1000 / 30);
}
}
private void VRInit()
{
// init
var error = EVRInitError.None;
system = OpenVR.Init(ref error);
if (error != EVRInitError.None)
{
throw new Exception();
}
OpenVR.GetGenericInterface(OpenVR.IVRSystem_Version, ref error);
if (error != EVRInitError.None)
{
throw new Exception();
}
TrackedDevicePose_t[] m_rTrackedDevicePose = new TrackedDevicePose_t[OpenVR.k_unMaxTrackedDeviceCount];
TrackedDevicePose_t TrackedDevicePose = new TrackedDevicePose_t();
VRControllerState_t controllerState = new VRControllerState_t();
while (true)
{
system.GetDeviceToAbsoluteTrackingPose(ETrackingUniverseOrigin.TrackingUniverseStanding, 0, m_rTrackedDevicePose);
for (uint unDevice = 0; unDevice < OpenVR.k_unMaxTrackedDeviceCount; unDevice++)
{
if (!system.IsTrackedDeviceConnected(unDevice))
{
continue;
}
HmdVector3_t position;
HmdQuaternion_t quaternion;
// Get what type of device it is and work with its data
ETrackedDeviceClass trackedDeviceClass = system.GetTrackedDeviceClass(unDevice);
ETrackedControllerRole trackedControllerRole = system.GetControllerRoleForTrackedDeviceIndex(unDevice);
ETrackingResult eTrackingResult;
switch (trackedDeviceClass)
{
case ETrackedDeviceClass.HMD:
// get the position and rotation
position = GetPosition(m_rTrackedDevicePose[unDevice].mDeviceToAbsoluteTracking);
quaternion = GetRotation(m_rTrackedDevicePose[unDevice].mDeviceToAbsoluteTracking);
// for printing some more info to the user about the state of the device/pose
eTrackingResult = m_rTrackedDevicePose[unDevice].eTrackingResult;
// print the tracking data
Dispatcher.Invoke(DispatcherPriority.Normal, new Action(delegate {
HmdIndex.Text = String.Format("{0}", unDevice);
HmdVectorX.Text = String.Format("{0:F4}", position.v0);
HmdVectorY.Text = String.Format("{0:F4}", position.v1);
HmdVectorZ.Text = String.Format("{0:F4}", position.v2);
HmdQuaternionX.Text = String.Format("{0:F4}", quaternion.x);
HmdQuaternionY.Text = String.Format("{0:F4}", quaternion.y);
HmdQuaternionZ.Text = String.Format("{0:F4}", quaternion.z);
HmdQuaternionW.Text = String.Format("{0:F4}", quaternion.w);
HmdState.Text = GetDeviceState(eTrackingResult);
}));
break;
case ETrackedDeviceClass.Controller:
// get the position and rotation
position = GetPosition(m_rTrackedDevicePose[unDevice].mDeviceToAbsoluteTracking);
quaternion = GetRotation(m_rTrackedDevicePose[unDevice].mDeviceToAbsoluteTracking);
// for printing some more info to the user about the state of the device/pose
eTrackingResult = m_rTrackedDevicePose[unDevice].eTrackingResult;
// get Controllers info
system.GetControllerStateWithPose(ETrackingUniverseOrigin.TrackingUniverseStanding, unDevice, ref controllerState, (uint)Marshal.SizeOf(controllerState), ref TrackedDevicePose);
switch (trackedControllerRole)
{
case ETrackedControllerRole.LeftHand:
// print the tracking data
Dispatcher.Invoke(DispatcherPriority.Normal, new Action(delegate {
CLIndex.Text = String.Format("{0}", unDevice);
CLVectorX.Text = String.Format("{0:F4}", position.v0);
CLVectorY.Text = String.Format("{0:F4}", position.v1);
CLVectorZ.Text = String.Format("{0:F4}", position.v2);
CLQuaternionX.Text = String.Format("{0:F4}", quaternion.x);
CLQuaternionY.Text = String.Format("{0:F4}", quaternion.y);
CLQuaternionZ.Text = String.Format("{0:F4}", quaternion.z);
CLQuaternionW.Text = String.Format("{0:F4}", quaternion.w);
CLState.Text = GetDeviceState(eTrackingResult);
CLulPressed.Text = String.Format("{0}", controllerState.ulButtonPressed);
CLulTouched.Text = String.Format("{0}", controllerState.ulButtonTouched);
CLAxis0X.Text = String.Format("{0:F4}", controllerState.rAxis0.x);
CLAxis0Y.Text = String.Format("{0:F4}", controllerState.rAxis0.y);
CLAxis1X.Text = String.Format("{0:F4}", controllerState.rAxis1.x);
CLAxis1Y.Text = String.Format("{0:F4}", controllerState.rAxis1.y);
CLAxis2X.Text = String.Format("{0:F4}", controllerState.rAxis2.x);
CLAxis2Y.Text = String.Format("{0:F4}", controllerState.rAxis2.y);
CLAxis3X.Text = String.Format("{0:F4}", controllerState.rAxis3.x);
CLAxis3Y.Text = String.Format("{0:F4}", controllerState.rAxis3.y);
CLAxis4X.Text = String.Format("{0:F4}", controllerState.rAxis4.x);
CLAxis4Y.Text = String.Format("{0:F4}", controllerState.rAxis4.y);
}));
break;
case ETrackedControllerRole.RightHand:
// print the tracking data
Dispatcher.Invoke(DispatcherPriority.Normal, new Action(delegate {
CRIndex.Text = String.Format("{0}", unDevice);
CRVectorX.Text = String.Format("{0:F4}", position.v0);
CRVectorY.Text = String.Format("{0:F4}", position.v1);
CRVectorZ.Text = String.Format("{0:F4}", position.v2);
CRQuaternionX.Text = String.Format("{0:F4}", quaternion.x);
CRQuaternionY.Text = String.Format("{0:F4}", quaternion.y);
CRQuaternionZ.Text = String.Format("{0:F4}", quaternion.z);
CRQuaternionW.Text = String.Format("{0:F4}", quaternion.w);
CRState.Text = GetDeviceState(eTrackingResult);
CRulPressed.Text = String.Format("{0}", controllerState.ulButtonPressed);
CRulTouched.Text = String.Format("{0}", controllerState.ulButtonTouched);
CRAxis0X.Text = String.Format("{0:F4}", controllerState.rAxis0.x);
CRAxis0Y.Text = String.Format("{0:F4}", controllerState.rAxis0.y);
CRAxis1X.Text = String.Format("{0:F4}", controllerState.rAxis1.x);
CRAxis1Y.Text = String.Format("{0:F4}", controllerState.rAxis1.y);
CRAxis2X.Text = String.Format("{0:F4}", controllerState.rAxis2.x);
CRAxis2Y.Text = String.Format("{0:F4}", controllerState.rAxis2.y);
CRAxis3X.Text = String.Format("{0:F4}", controllerState.rAxis3.x);
CRAxis3Y.Text = String.Format("{0:F4}", controllerState.rAxis3.y);
CRAxis4X.Text = String.Format("{0:F4}", controllerState.rAxis4.x);
CRAxis4Y.Text = String.Format("{0:F4}", controllerState.rAxis4.y);
}));
break;
}
break;
case ETrackedDeviceClass.GenericTracker:
system.GetControllerStateWithPose(ETrackingUniverseOrigin.TrackingUniverseStanding, unDevice, ref controllerState, (uint)Marshal.SizeOf(controllerState), ref TrackedDevicePose);
// get the position and rotation
position = GetPosition(TrackedDevicePose.mDeviceToAbsoluteTracking);
quaternion = GetRotation(TrackedDevicePose.mDeviceToAbsoluteTracking);
// for printing some more info to the user about the state of the device/pose
eTrackingResult = m_rTrackedDevicePose[unDevice].eTrackingResult;
// print the tracking data
Dispatcher.Invoke(DispatcherPriority.Normal, new Action(delegate {
TrackerIndex.Text = String.Format("{0}", unDevice);
TrackerVectorX.Text = String.Format("{0:F4}", position.v0);
TrackerVectorY.Text = String.Format("{0:F4}", position.v1);
TrackerVectorZ.Text = String.Format("{0:F4}", position.v2);
TrackerQuaternionX.Text = String.Format("{0:F4}", quaternion.x);
TrackerQuaternionY.Text = String.Format("{0:F4}", quaternion.y);
TrackerQuaternionZ.Text = String.Format("{0:F4}", quaternion.z);
TrackerQuaternionW.Text = String.Format("{0:F4}", quaternion.w);
TrackerState.Text = GetDeviceState(eTrackingResult);
}));
break;
}
Thread.Sleep(10);
}
}
}
/// <summary>
/// Creates a GameObject that represents the left or right device controllers.
/// These are the "VR hands".
/// </summary>
/// <param name="role">The controller device role (left or right).</param>
/// <returns>The GameObject for the "VR hand".</returns>
protected GameObject CreateManipulator(ETrackedControllerRole role)
{
// create new GameObject
GameObject manipulator = new GameObject("KVR_Manipulator_" + role.ToString());
DontDestroyOnLoad(manipulator);
// define the render model
GameObject glovePrefab = AssetLoader.Instance.GetGameObject("GlovePrefab");
if (glovePrefab == null)
{
Utils.LogError("GameObject \"GlovePrefab\" was not found!");
return(manipulator);
}
GameObject gloveObject = Instantiate(glovePrefab);
gloveObject.transform.SetParent(manipulator.transform);
Vector3 gloveObjectScale = Vector3.one * ManipulatorSize;
if (role == ETrackedControllerRole.RightHand)
{
gloveObjectScale.y *= -1f;
}
gloveObject.transform.localPosition = GLOVE_POSITION;
gloveObject.transform.localRotation = Quaternion.Euler(GLOVE_ROTATION);
gloveObject.transform.localScale = gloveObjectScale;
Utils.SetLayer(gloveObject, 20);
// define the colliders
Transform colliderObject = gloveObject.transform.Find("HandDummy/Arm Bone L/Wrist Bone L/Finger Index Bone L1/Finger Index Bone L2/Finger Index Bone L3/Finger Index Bone L4");
if (colliderObject == null)
{
Utils.LogWarning("Manipulator is missing fingertip collider child object");
return(manipulator);
}
SphereCollider fingertipCollider = colliderObject.GetComponent <SphereCollider>();
colliderObject = gloveObject.transform.Find("HandDummy/Arm Bone L/Wrist Bone L");
if (colliderObject == null)
{
Utils.LogWarning("Manipulator is missing grip collider child object");
return(manipulator);
}
CapsuleCollider gripCollider = colliderObject.GetComponent <CapsuleCollider>();
// retrieve the animator
Animator manipulatorAnimator = gloveObject.GetComponent <Animator>();
// define the Manipulator component
Manipulator manipulatorComponent = manipulator.AddComponent <Manipulator>();
manipulatorComponent.role = role;
manipulatorComponent.fingertipCollider = fingertipCollider;
manipulatorComponent.gripCollider = gripCollider;
manipulatorComponent.manipulatorAnimator = manipulatorAnimator;
#if DEBUG
GameObject manipulatorGizmo = Utils.CreateGizmo();
manipulatorGizmo.transform.SetParent(manipulator.transform);
manipulatorGizmo.transform.localPosition = Vector3.zero;
manipulatorGizmo.transform.localRotation = Quaternion.identity;
manipulatorGizmo.transform.localScale = Vector3.one * 0.5f;
#endif
return(manipulator);
}
public override uint GetTrackedDeviceIndexForControllerRole(ETrackedControllerRole unDeviceType)
{
CheckIfUsable();
uint result = VRNativeEntrypoints.VR_IVRSystem_GetTrackedDeviceIndexForControllerRole(m_pVRSystem,unDeviceType);
return result;
}
private bool StartupOVR()
{
EVRInitError error = EVRInitError.Driver_Failed;
vr = OpenVR.Init(ref error, EVRApplicationType.VRApplication_Overlay);
if (error != EVRInitError.None)
{
Debug.WriteLine("OpenVR Init Error: " + error.ToString());
return(false);
}
overlay = OpenVR.Overlay;
EVROverlayError overlayError = overlay.CreateOverlay("Jstf_ovr_cards", "OpenVR Cards System Overlay", ref overlayHandle);
if (overlayError != EVROverlayError.None)
{
OpenVR.Shutdown();
Debug.WriteLine("OpenVR Overlay Error: " + overlayError.ToString());
return(false);
}
/*overlayError = overlay.SetOverlayFromFile(overlayHandle, AssetsPath + "overlay.png");
* if (overlayError != EVROverlayError.None)
* {
* CleanupOVR();
* Debug.WriteLine("OpenVR Overlay Error: " + overlayError.ToString());
* return false;
* }*/
overlayError = overlay.SetOverlayInputMethod(overlayHandle, VROverlayInputMethod.Mouse);
if (overlayError != EVROverlayError.None)
{
CleanupOVR();
Debug.WriteLine("OpenVR Overlay Error: " + overlayError.ToString());
return(false);
}
overlayTexture = new Texture_t
{
eType = ETextureType.OpenGL,
eColorSpace = EColorSpace.Auto,
handle = (IntPtr)textureId
};
overlayError = overlay.SetOverlayTexture(overlayHandle, ref overlayTexture);
if (overlayError != EVROverlayError.None)
{
CleanupOVR();
Debug.WriteLine("OpenVR Overlay Error: " + overlayError.ToString());
return(false);
}
HmdId = OpenVR.k_unTrackedDeviceIndex_Hmd;
for (uint i = HmdId + 1; i < OpenVR.k_unMaxTrackedDeviceCount; i++)
{
if (vr.IsTrackedDeviceConnected(i))
{
ETrackedDeviceClass cls = vr.GetTrackedDeviceClass(i);
if (cls == ETrackedDeviceClass.Controller)
{
ETrackedControllerRole rl = vr.GetControllerRoleForTrackedDeviceIndex(i);
if (rl == ETrackedControllerRole.LeftHand)
{
LeftControllerId = i;
Debug.WriteLine("Found Left Controller");
}
else if (rl == ETrackedControllerRole.RightHand)
{
RightControllerId = i;
Debug.WriteLine("Found Right Controller");
}
}
}
}
mat = new HmdMatrix34_t
{
m0 = 1,
m1 = 0,
m2 = 0,
m3 = 0f,
m4 = 0,
m5 = 1,
m6 = 0,
m7 = 0.1f,
m8 = 0,
m9 = 0,
m10 = 1,
m11 = 0f
};
overlayError = overlay.SetOverlayTransformTrackedDeviceRelative(overlayHandle, RightControllerId, ref mat);
if (overlayError != EVROverlayError.None)
{
Debug.WriteLine("Cannot bind overlay to Tracked device.");
Debug.WriteLine("Error: " + overlayError.ToString());
CleanupOVR();
return(false);
}
overlayError = overlay.SetOverlayWidthInMeters(overlayHandle, 0.2f);
if (overlayError != EVROverlayError.None)
{
Debug.WriteLine("Cannot set overlay size.");
Debug.WriteLine("Error: " + overlayError.ToString());
CleanupOVR();
return(false);
}
overlayError = overlay.SetOverlayAlpha(overlayHandle, 1);
if (overlayError != EVROverlayError.None)
{
Debug.WriteLine("Cannot set overlay alpha.");
Debug.WriteLine("Error: " + overlayError.ToString());
CleanupOVR();
return(false);
}
overlayError = overlay.SetOverlayColor(overlayHandle, 1, 1, 1);
if (overlayError != EVROverlayError.None)
{
Debug.WriteLine("Cannot set overlay color.");
Debug.WriteLine("Error: " + overlayError.ToString());
CleanupOVR();
return(false);
}
#if DEBUG
Debug.WriteLine("OpenVR Startup Complete");
#endif
return(true);
}
public uint GetTrackedDeviceIndexForControllerRole(ETrackedControllerRole unDeviceType)
{
uint result = FnTable.GetTrackedDeviceIndexForControllerRole(unDeviceType);
return result;
}
private bool ProcessVREvent(VREvent_t event_T)
{
switch (event_T.eventType)
{
case (uint)EVREventType.VREvent_Quit:
Shutdown();
return(false);
case (uint)EVREventType.VREvent_QuitAborted_UserPrompt:
return(false);
case (uint)EVREventType.VREvent_QuitAcknowledged:
return(false);
case (uint)EVREventType.VREvent_ButtonPress:
int msgIdentifyer = 102;
switch (event_T.data.controller.button)
{
case (uint)EVRButtonId.k_EButton_SteamVR_Touchpad:
Console.WriteLine("Touchpad");
ETrackedControllerRole result = vr_pointer.GetControllerRoleForTrackedDeviceIndex(event_T.trackedDeviceIndex);
if (result == ETrackedControllerRole.LeftHand)
{
int handid = 1;
MessageBuffer mb = new MessageBuffer();
mb.add(msgIdentifyer);
mb.add((int)EVRButtonId.k_EButton_SteamVR_Touchpad);
mb.add(userId);
mb.add(handid);
Message msg = new Message(mb, Message.MessagesType.COVISE_MESSAGE_VRB_MESSAGE);
lock (tcpSocketManager.send_msg(msg))
{
tcpSocketManager.send_msg(msg);
}
}
else
{
int handid = 2;
MessageBuffer mb = new MessageBuffer();
mb.add(msgIdentifyer);
mb.add((int)EVRButtonId.k_EButton_SteamVR_Touchpad);
mb.add(userId);
mb.add(handid);
Message msg = new Message(mb, Message.MessagesType.COVISE_MESSAGE_VRB_MESSAGE);
lock (tcpSocketManager.send_msg(msg))
{
tcpSocketManager.send_msg(msg);
}
}
return(false);
case (uint)EVRButtonId.k_EButton_ApplicationMenu:
Console.WriteLine("ButttonAplication");
ETrackedControllerRole result2 = vr_pointer.GetControllerRoleForTrackedDeviceIndex(event_T.trackedDeviceIndex);
if (result2 == ETrackedControllerRole.LeftHand)
{
int handid = 1;
MessageBuffer mb = new MessageBuffer();
mb.add(msgIdentifyer);
mb.add((int)EVRButtonId.k_EButton_ApplicationMenu);
mb.add(userId);
mb.add(handid);
Message msg = new Message(mb, Message.MessagesType.COVISE_MESSAGE_VRB_MESSAGE);
lock (tcpSocketManager.send_msg(msg))
{
tcpSocketManager.send_msg(msg);
}
}
else
{
int handid = 2;
MessageBuffer mb = new MessageBuffer();
mb.add(msgIdentifyer);
mb.add((int)EVRButtonId.k_EButton_ApplicationMenu);
mb.add(userId);
mb.add(handid);
Message msg = new Message(mb, Message.MessagesType.COVISE_MESSAGE_VRB_MESSAGE);
lock (tcpSocketManager.send_msg(msg))
{
tcpSocketManager.send_msg(msg);
}
}
return(false);
case (uint)EVRButtonId.k_EButton_System:
Console.WriteLine("ButtonSystem");
ETrackedControllerRole result3 = vr_pointer.GetControllerRoleForTrackedDeviceIndex(event_T.trackedDeviceIndex);
if (result3 == ETrackedControllerRole.LeftHand)
{
int handid = 1;
MessageBuffer mb = new MessageBuffer();
mb.add(msgIdentifyer);
mb.add((int)EVRButtonId.k_EButton_System);
mb.add(userId);
mb.add(handid);
Message msg = new Message(mb, Message.MessagesType.COVISE_MESSAGE_VRB_MESSAGE);
lock (tcpSocketManager.send_msg(msg))
{
tcpSocketManager.send_msg(msg);
}
}
else
{
int handid = 2;
MessageBuffer mb = new MessageBuffer();
mb.add(msgIdentifyer);
mb.add((int)EVRButtonId.k_EButton_System);
mb.add(userId);
mb.add(handid);
Message msg = new Message(mb, Message.MessagesType.COVISE_MESSAGE_VRB_MESSAGE);
lock (tcpSocketManager.send_msg(msg))
{
tcpSocketManager.send_msg(msg);
}
}
return(false);
case (uint)EVRButtonId.k_EButton_SteamVR_Trigger:
Console.WriteLine("Trigger");
ETrackedControllerRole result4 = vr_pointer.GetControllerRoleForTrackedDeviceIndex(event_T.trackedDeviceIndex);
if (result4 == ETrackedControllerRole.LeftHand)
{
int handid = 1;
MessageBuffer mb = new MessageBuffer();
mb.add(msgIdentifyer);
mb.add((int)EVRButtonId.k_EButton_SteamVR_Trigger);
mb.add(userId);
mb.add(handid);
Message msg = new Message(mb, Message.MessagesType.COVISE_MESSAGE_VRB_MESSAGE);
lock (tcpSocketManager.send_msg(msg))
{
tcpSocketManager.send_msg(msg);
}
}
else
{
int handid = 2;
MessageBuffer mb = new MessageBuffer();
mb.add(msgIdentifyer);
mb.add((int)EVRButtonId.k_EButton_SteamVR_Trigger);
mb.add(userId);
mb.add(handid);
Message msg = new Message(mb, Message.MessagesType.COVISE_MESSAGE_VRB_MESSAGE);
lock (tcpSocketManager.send_msg(msg))
{
tcpSocketManager.send_msg(msg);
}
}
return(false);
case (uint)EVRButtonId.k_EButton_Grip:
Console.WriteLine("Grip");
ETrackedControllerRole result5 = vr_pointer.GetControllerRoleForTrackedDeviceIndex(event_T.trackedDeviceIndex);
if (result5 == ETrackedControllerRole.LeftHand)
{
int handid = 1;
MessageBuffer mb = new MessageBuffer();
mb.add(msgIdentifyer);
mb.add((int)EVRButtonId.k_EButton_Grip);
mb.add(userId);
mb.add(handid);
Message msg = new Message(mb, Message.MessagesType.COVISE_MESSAGE_VRB_MESSAGE);
lock (tcpSocketManager.send_msg(msg))
{
tcpSocketManager.send_msg(msg);
}
}
else
{
int handid = 2;
MessageBuffer mb = new MessageBuffer();
mb.add(msgIdentifyer);
mb.add((int)EVRButtonId.k_EButton_Grip);
mb.add(userId);
mb.add(handid);
Message msg = new Message(mb, Message.MessagesType.COVISE_MESSAGE_VRB_MESSAGE);
lock (tcpSocketManager.send_msg(msg))
{
tcpSocketManager.send_msg(msg);
}
}
return(false);
}
return(false);
default:
return(false);
}
}
private async void ParseTrackingFrame()
{
try
{
for (uint id = 0; id < OpenVR.k_unMaxTrackedDeviceCount; id++)
{
if (vr_pointer != null)
{
TrackedDevicePose_t[] trackedDevicePose = new TrackedDevicePose_t[OpenVR.k_unMaxTrackedDeviceCount];
if (!vr_pointer.IsTrackedDeviceConnected(id))
{
continue;
}
VRControllerState_t controllState = new VRControllerState_t();
ETrackedDeviceClass trackedDeviceClass = vr_pointer.GetTrackedDeviceClass(id);
switch (trackedDeviceClass)
{
case ETrackedDeviceClass.Controller:
vr_pointer.GetControllerStateWithPose(ETrackingUniverseOrigin.TrackingUniverseStanding, id, ref controllState, OpenVR.k_unMaxTrackedDeviceCount, ref trackedDevicePose[id]);
HmdVector3_t position = GetPosition(trackedDevicePose[id].mDeviceToAbsoluteTracking); // devicePose->mDeviceToAbsoluteTracking);
HmdVector3_t rotation = GetRotationEuler(trackedDevicePose[id].mDeviceToAbsoluteTracking);
int positionControllerX = (int)position.v0;
int positionControllerY = (int)position.v1;
int positionControllerZ = (int)position.v2 * (-1);
int rotationControllerX = (int)rotation.v0 + 180;
int rotationControllerY = (int)rotation.v1;
int rotationControllerZ = (int)rotation.v2;
if (ControlViewModel.teleporOffset[0] != -1)
{
ControlViewModel.transOffSetControllerX = ControlViewModel.teleporOffset[0];
ControlViewModel.transOffSetControllerY = ControlViewModel.teleporOffset[1];
ControlViewModel.transOffSetControllerZ = ControlViewModel.teleporOffset[2];
ControlViewModel.rotOffSetControllerZ = ControlViewModel.teleporOffset[3];
}
ETrackedControllerRole result = vr_pointer.GetControllerRoleForTrackedDeviceIndex(id);
if (result != ETrackedControllerRole.LeftHand && lastController != ETrackedControllerRole.LeftHand)
{
RaiseControllerEvent(new TrackingChangedEventArgs(false), Tracker.LeftController);
}
if (result != ETrackedControllerRole.RightHand && lastController != ETrackedControllerRole.RightHand)
{
RaiseControllerEvent(new TrackingChangedEventArgs(false), Tracker.RightController);
}
switch (result)
{
case ETrackedControllerRole.Invalid:
break;
case ETrackedControllerRole.LeftHand:
if (communicationProtocolUdp == false)
{
MessageBuffer mb2 = new MessageBuffer();
someThingTracked = true;
int type = 101;
mb2.add(type);
mb2.add(userId);
int handid = 1;
mb2.add(handid);
mb2.add(positionControllerX + ControlViewModel.transOffSetControllerX);
mb2.add(positionControllerY + ControlViewModel.transOffSetControllerY);
mb2.add(positionControllerZ + ControlViewModel.transOffSetControllerZ);
mb2.add(rotationControllerX);
mb2.add(rotationControllerY);
mb2.add(rotationControllerZ);
mb2.add(ControlViewModel.rotOffSetControllerZ);
RaiseControllerEvent(new TrackingChangedEventArgs(true), Tracker.LeftController);
Message msg = new Message(mb2, Message.MessagesType.COVISE_MESSAGE_VRB_MESSAGE);
lock (tcpSocketManager.send_msg(msg))
{
tcpSocketManager.send_msg(msg);
}
Thread.Sleep(20);
break;
}
break;
case ETrackedControllerRole.RightHand:
if (communicationProtocolUdp == false)
{
MessageBuffer mb2 = new MessageBuffer();
someThingTracked = true;
int type = 101;
mb2.add(type);
mb2.add(userId);
int handid = 2;
mb2.add(handid);
mb2.add(positionControllerX + ControlViewModel.transOffSetControllerX);
mb2.add(positionControllerY + ControlViewModel.transOffSetControllerY);
mb2.add(positionControllerZ + ControlViewModel.transOffSetControllerZ);
mb2.add(rotationControllerX);
mb2.add(rotationControllerY);
mb2.add(rotationControllerZ);
mb2.add(ControlViewModel.rotOffSetControllerZ);
Message msg = new Message(mb2, Message.MessagesType.COVISE_MESSAGE_VRB_MESSAGE);
RaiseControllerEvent(new TrackingChangedEventArgs(true), Tracker.RightController);
lock (tcpSocketManager.send_msg(msg))
{
tcpSocketManager.send_msg(msg);
}
Thread.Sleep(20);
break;
}
break;
}
break;
}
}
}
}
catch (Exception e)
{
log.Warn("ParseTrackingFrame in Controller Tracking wurde beendet!" + e);
RaiseControllerEvent(new TrackingChangedEventArgs(false), Tracker.LeftController);
RaiseControllerEvent(new TrackingChangedEventArgs(false), Tracker.RightController);
}
}
public bool GetDevices(Dictionary <string, TrackedDevice> devices)
{
devices.Clear();
bool changeDetected = false;
_openVRFacade.GetDeviceToAbsoluteTrackingPose(ETrackingUniverseOrigin.TrackingUniverseStanding, _poses);
for (uint i = 0; i < _poses.Length; i++)
{
OpenVRDevice device = _devices[i];
TrackedDevicePose_t pose = _poses[i];
DeviceUse use = DeviceUse.Unknown;
string id = device.id;
bool isConnected = device.isConnected;
string modelName = device.modelName;
if (pose.bDeviceIsConnected != isConnected)
{
isConnected = pose.bDeviceIsConnected;
if (pose.bDeviceIsConnected)
{
string serialNumber = _openVRFacade.GetStringTrackedDeviceProperty(i, ETrackedDeviceProperty.Prop_SerialNumber_String);
modelName = _openVRFacade.GetStringTrackedDeviceProperty(i, ETrackedDeviceProperty.Prop_ModelNumber_String);
id = string.Concat(modelName ?? "Unknown", " ", (uint)serialNumber?.GetHashCode(), "@", i);
_logger.Info($"Device '{id}' connected");
}
else
{
_logger.Info($"Device '{id}' disconnected");
id = null;
modelName = null;
}
changeDetected = true;
}
if (!isConnected)
{
_devices[i] = default;
continue;
}
ETrackedDeviceClass deviceClass = _openVRFacade.GetTrackedDeviceClass(i);
ETrackedControllerRole controllerRole = _openVRFacade.GetControllerRoleForTrackedDeviceIndex(i);
string role = _openVRFacade.GetStringTrackedDeviceProperty(i, ETrackedDeviceProperty.Prop_ControllerType_String);
if (deviceClass != device.deviceClass)
{
_logger.Trace($"Device '{id}' class changed from '{device.deviceClass}' to '{deviceClass}'");
changeDetected = true;
}
if (controllerRole != device.controllerRole)
{
_logger.Trace($"Device '{id}' controller role changed from '{device.controllerRole}' to '{controllerRole}'");
changeDetected = true;
}
if (role != device.role)
{
if (role == null)
{
_logger.Trace($"Device '{id}' role unset from '{device.role}'");
}
else if (device.role == null)
{
_logger.Trace($"Device '{id}' role set to '{role}'");
}
else
{
_logger.Trace($"Device '{id}' role changed from '{device.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 = pose.bPoseIsValid && kValidTrackingResults.Contains(pose.eTrackingResult);
if (device.isTracking != isTracking)
{
if (isTracking)
{
_logger.Info($"Acquired tracking of device '{id}'");
}
else
{
_logger.Info($"Lost tracking of device '{id}'");
}
changeDetected = true;
}
Vector3 position = Vector3.zero;
Quaternion rotation = Quaternion.identity;
if (isTracking)
{
_openVRFacade.GetPositionAndRotation(pose.mDeviceToAbsoluteTracking, out position, out rotation);
// 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(id, isConnected, isTracking, controllerRole, deviceClass, modelName, role);
devices.Add(id, new TrackedDevice(id, use, isTracking, position, rotation));
}
return(changeDetected);
}
} // 0x00000001811DFF00-0x00000001811DFF30
public uint GetTrackedDeviceIndexForControllerRole(ETrackedControllerRole unDeviceType) => default; // 0x00000001811E0AC0-0x00000001811E0AF0