Remove redundent script in UnityEngineVRModule

Author: lawwong

Assets/HTC.UnityPlugin/VRModule/Modules/UnityEngineVRModule.cs

@@ -2,6 +2,13 @@
 
 using UnityEngine;
 
+#if UNITY_2017_2_OR_NEWER
+using UnityEngine.XR;
+#else
+using XRSettings = UnityEngine.VR.VRSettings;
+using XRDevice = UnityEngine.VR.VRDevice;
+#endif
+
 namespace HTC.UnityPlugin.VRModuleManagement
 {
     public sealed partial class UnityEngineVRModule : VRModule.ModuleBase
@@ -103,38 +110,16 @@ public static class ButtonAxisID
             public static int Index(int i) { return s_ids[i]; }
         }
 #endif
-
-#if UNITY_2017_2_OR_NEWER
-        public override bool ShouldActiveModule() { return UnityEngine.XR.XRSettings.enabled; }
-#else
-        public override bool ShouldActiveModule() { return UnityEngine.VR.VRSettings.enabled; }
-#endif
-
-#if UNITY_5_6_OR_NEWER
-        public override void OnActivated()
-        {
-            SaveTrackingSpaceType();
-            UpdateTrackingSpaceType();
-        }
-#endif
-
-#if UNITY_5_6_OR_NEWER
-        public override void OnDeactivated()
-        {
-            LoadTrackingSpaceType();
-        }
-#endif
+        public override bool ShouldActiveModule() { return XRSettings.enabled; }
 
         public override void Update()
         {
             // set physics update rate to vr render rate
             if (VRModule.lockPhysicsUpdateRateToRenderFrequency && Time.timeScale > 0.0f)
             {
                 // FIXME: VRDevice.refreshRate returns zero in Unity 5.6.0 or older version
-#if UNITY_2017_2_OR_NEWER
-                Time.fixedDeltaTime = 1f / UnityEngine.XR.XRDevice.refreshRate;
-#elif UNITY_5_6_OR_NEWER
-                Time.fixedDeltaTime = 1f / UnityEngine.VR.VRDevice.refreshRate;
+#if UNITY_5_6_OR_NEWER
+                Time.fixedDeltaTime = 1f / XRDevice.refreshRate;
 #else
                 Time.fixedDeltaTime = 1f / 90f;
 #endif

Assets/HTC.UnityPlugin/VRModule/Modules/UnityEngineVRModule_2017_1.cs

@@ -1,48 +1,85 @@
 //========= Copyright 2016-2017, HTC Corporation. All rights reserved. ===========
 
-#if UNITY_2017_1_OR_NEWER && !UNITY_2017_2_OR_NEWER
+#if UNITY_2017_1_OR_NEWER
+
 using HTC.UnityPlugin.Utility;
 using System.Collections.Generic;
 using UnityEngine;
+
+#if UNITY_2017_2_OR_NEWER
+using UnityEngine.XR;
+#else
 using UnityEngine.VR;
+using XRSettings = UnityEngine.VR.VRSettings;
+using XRDevice = UnityEngine.VR.VRDevice;
+using XRNodeState = UnityEngine.VR.VRNodeState;
+using XRNode = UnityEngine.VR.VRNode;
+#endif
+
 #endif
 
 namespace HTC.UnityPlugin.VRModuleManagement
 {
     public sealed partial class UnityEngineVRModule : VRModule.ModuleBase
     {
-#if UNITY_2017_1_OR_NEWER && !UNITY_2017_2_OR_NEWER
+#if UNITY_2017_1_OR_NEWER
         private uint m_leftIndex = INVALID_DEVICE_INDEX;
         private uint m_rightIndex = INVALID_DEVICE_INDEX;
 
         private Dictionary<ulong, uint> m_node2Index = new Dictionary<ulong, uint>();
         private bool[] m_nodeStatesValid = new bool[MAX_DEVICE_COUNT];
-        private List<VRNodeState> m_nodeStateList = new List<VRNodeState>();
+        private List<XRNodeState> m_nodeStateList = new List<XRNodeState>();
 
         private IndexedSet<ulong> m_prevExistNodeUids = new IndexedSet<ulong>();
         private IndexedSet<ulong> m_currExistNodeUids = new IndexedSet<ulong>();
 
+        private TrackingSpaceType m_prevTrackingSpace;
+
+        public override void OnActivated()
+        {
+            m_prevTrackingSpace = XRDevice.GetTrackingSpaceType();
+            UpdateTrackingSpaceType();
+        }
+
+        public override void OnDeactivated()
+        {
+            XRDevice.SetTrackingSpaceType(m_prevTrackingSpace);
+        }
+
         public override uint GetLeftControllerDeviceIndex() { return m_leftIndex; }
 
         public override uint GetRightControllerDeviceIndex() { return m_rightIndex; }
 
-        private bool IsTrackingDeviceNode(VRNodeState nodeState)
+        public override void UpdateTrackingSpaceType()
+        {
+            switch (VRModule.trackingSpaceType)
+            {
+                case VRModuleTrackingSpaceType.Stationary:
+                    XRDevice.SetTrackingSpaceType(TrackingSpaceType.Stationary);
+                    break;
+                case VRModuleTrackingSpaceType.RoomScale:
+                    XRDevice.SetTrackingSpaceType(TrackingSpaceType.RoomScale);
+                    break;
+            }
+        }
+
+        private bool IsTrackingDeviceNode(XRNodeState nodeState)
         {
             switch (nodeState.nodeType)
             {
-                case VRNode.Head:
-                case VRNode.RightHand:
-                case VRNode.LeftHand:
-                case VRNode.GameController:
-                case VRNode.HardwareTracker:
-                case VRNode.TrackingReference:
+                case XRNode.Head:
+                case XRNode.RightHand:
+                case XRNode.LeftHand:
+                case XRNode.GameController:
+                case XRNode.HardwareTracker:
+                case XRNode.TrackingReference:
                     return true;
                 default:
                     return false;
             }
         }
 
-        private bool TryGetNodeDeviceIndex(VRNodeState nodeState, out uint deviceIndex)
+        private bool TryGetNodeDeviceIndex(XRNodeState nodeState, out uint deviceIndex)
         {
             // only tracking certain type of node (some nodes share same uniqueID)
             if (!IsTrackingDeviceNode(nodeState)) { deviceIndex = 0; return false; }
@@ -54,7 +91,7 @@ private bool TryGetNodeDeviceIndex(VRNodeState nodeState, out uint deviceIndex)
 
                 var validIndexFound = false;
 
-                if (nodeState.nodeType == VRNode.Head)
+                if (nodeState.nodeType == XRNode.Head)
                 {
                     if (m_nodeStatesValid[0])
                     {
@@ -79,8 +116,8 @@ private bool TryGetNodeDeviceIndex(VRNodeState nodeState, out uint deviceIndex)
 
                             switch (nodeState.nodeType)
                             {
-                                case VRNode.RightHand: m_rightIndex = i; break;
-                                case VRNode.LeftHand: m_leftIndex = i; break;
+                                case XRNode.RightHand: m_rightIndex = i; break;
+                                case XRNode.LeftHand: m_leftIndex = i; break;
                             }
 
                             deviceIndex = i;
@@ -92,7 +129,7 @@ private bool TryGetNodeDeviceIndex(VRNodeState nodeState, out uint deviceIndex)
 
                 if (!validIndexFound)
                 {
-                    Debug.LogWarning("[" + Time.frameCount + "] VRNode added, but device index out of range, drop the node id:" + nodeState.uniqueID.ToString("X8") + " type:" + nodeState.nodeType + " name:" + InputTracking.GetNodeName(nodeState.uniqueID) + " tracked=" + nodeState.tracked);
+                    Debug.LogWarning("[" + Time.frameCount + "] XRNode added, but device index out of range, drop the node id:" + nodeState.uniqueID.ToString("X8") + " type:" + nodeState.nodeType + " name:" + InputTracking.GetNodeName(nodeState.uniqueID) + " tracked=" + nodeState.tracked);
                     return false;
                 }
 
@@ -102,7 +139,7 @@ private bool TryGetNodeDeviceIndex(VRNodeState nodeState, out uint deviceIndex)
             return true;
         }
 
-        private void RemoveNodeDeviceIndex(ulong uniqueID)
+        private uint RemoveNodeDeviceIndex(ulong uniqueID)
         {
             var deviceIndex = INVALID_DEVICE_INDEX;
             if (m_node2Index.TryGetValue(uniqueID, out deviceIndex))
@@ -113,11 +150,13 @@ private void RemoveNodeDeviceIndex(ulong uniqueID)
                 if (deviceIndex == m_rightIndex) { m_rightIndex = INVALID_DEVICE_INDEX; }
                 if (deviceIndex == m_leftIndex) { m_leftIndex = INVALID_DEVICE_INDEX; }
             }
+
+            return deviceIndex;
         }
 
         public override void UpdateDeviceState(IVRModuleDeviceState[] prevState, IVRModuleDeviceStateRW[] currState)
         {
-            if (VRSettings.isDeviceActive && VRDevice.isPresent)
+            if (XRSettings.isDeviceActive && XRDevice.isPresent)
             {
                 InputTracking.GetNodeStates(m_nodeStateList);
             }
@@ -143,24 +182,24 @@ public override void UpdateDeviceState(IVRModuleDeviceState[] prevState, IVRModu
 
                 switch (m_nodeStateList[i].nodeType)
                 {
-                    case VRNode.Head:
+                    case XRNode.Head:
                         currDeviceState.deviceClass = VRModuleDeviceClass.HMD;
                         break;
-                    case VRNode.RightHand:
+                    case XRNode.RightHand:
                         currDeviceState.deviceClass = VRModuleDeviceClass.Controller;
                         rightIndex = deviceIndex;
                         break;
-                    case VRNode.LeftHand:
+                    case XRNode.LeftHand:
                         currDeviceState.deviceClass = VRModuleDeviceClass.Controller;
                         leftIndex = deviceIndex;
                         break;
-                    case VRNode.GameController:
+                    case XRNode.GameController:
                         currDeviceState.deviceClass = VRModuleDeviceClass.Controller;
                         break;
-                    case VRNode.HardwareTracker:
+                    case XRNode.HardwareTracker:
                         currDeviceState.deviceClass = VRModuleDeviceClass.GenericTracker;
                         break;
-                    case VRNode.TrackingReference:
+                    case XRNode.TrackingReference:
                         currDeviceState.deviceClass = VRModuleDeviceClass.TrackingReference;
                         break;
                     default:
@@ -172,9 +211,9 @@ public override void UpdateDeviceState(IVRModuleDeviceState[] prevState, IVRModu
                 {
                     // FIXME: getting wrong name in Unity 2017.1f1
                     //currDeviceState.serialNumber = InputTracking.GetNodeName(m_nodeStateList[i].uniqueID) ?? string.Empty;
-                    currDeviceState.serialNumber = VRDevice.model + " " + m_nodeStateList[i].uniqueID.ToString("X8");
-                    currDeviceState.modelNumber = VRDevice.model + " " + m_nodeStateList[i].nodeType;
-                    currDeviceState.renderModelName = VRDevice.model + " " + m_nodeStateList[i].nodeType;
+                    currDeviceState.serialNumber = XRDevice.model + " " + m_nodeStateList[i].uniqueID.ToString("X8");
+                    currDeviceState.modelNumber = XRDevice.model + " " + m_nodeStateList[i].nodeType;
+                    currDeviceState.renderModelName = XRDevice.model + " " + m_nodeStateList[i].nodeType;
 
                     SetupKnownDeviceModel(currDeviceState);
                 }
@@ -273,8 +312,11 @@ public override void UpdateDeviceState(IVRModuleDeviceState[] prevState, IVRModu
             // remove disconnected nodes
             for (int i = m_prevExistNodeUids.Count - 1; i >= 0; --i)
             {
-                if (currState[i].isConnected) { currState[i].Reset(); }
-                RemoveNodeDeviceIndex(m_prevExistNodeUids[i]);
+                var removedIndex = RemoveNodeDeviceIndex(m_prevExistNodeUids[i]);
+                if (VRModule.IsValidDeviceIndex(removedIndex))
+                {
+                    currState[removedIndex].Reset();
+                }
             }
 
             var temp = m_prevExistNodeUids;