Added NVRVirtualHand and NVRVirtualInputDevice to use with NPC and remote users

.gitignore

@@ -19,3 +19,11 @@
 
 # Unity3D Generated File On Crash Reports
 sysinfo.txt
+
+Assets/Plugins.meta
+Assets/Plugins/
+Assets/OVR.meta
+Assets/OVR/
+Assets/SteamVR.meta
+Assets/SteamVR/
+

Assets/NewtonVR/NVRButtonInput.cs

@@ -14,15 +14,15 @@ public bool PressDown
             {
                 if (PressDownExpired)
                 {
-                    PressDownCached = InputDevice.GetPressDown(NVRbutton);
+                    PressDownCached = (InputDevice != null) ? InputDevice.GetPressDown(NVRbutton) : false;
                     PressDownExpired = false;
                 }
                 return PressDownCached;
             }
         }
 
         private bool PressDownCached;
-        private bool PressDownExpired = false;
+        private bool PressDownExpired = true;
 
         /// <summary>Is true ONLY on the frame that the button is released after being pressed down</summary>
         public bool PressUp
@@ -31,15 +31,15 @@ public bool PressUp
             {
                 if (PressUpExpired)
                 {
-                    PressUpCached = InputDevice.GetPressUp(NVRbutton);
+                    PressUpCached = (InputDevice != null) ? InputDevice.GetPressUp(NVRbutton) : false;
                     PressUpExpired = false;
                 }
                 return PressUpCached;
             }
         }
 
         private bool PressUpCached;
-        private bool PressUpExpired = false;
+        private bool PressUpExpired = true;
 
         /// <summary>Is true WHENEVER the button is pressed down</summary>
         public bool IsPressed
@@ -48,15 +48,15 @@ public bool IsPressed
             {
                 if (IsPressedExpired)
                 {
-                    IsPressedCached = InputDevice.GetPress(NVRbutton);
+                    IsPressedCached = (InputDevice != null) ? InputDevice.GetPress(NVRbutton) : false;
                     IsPressedExpired = false;
                 }
                 return IsPressedCached;
             }
         }
 
         private bool IsPressedCached;
-        private bool IsPressedExpired = false;
+        private bool IsPressedExpired = true;
 
         /// <summary>Is true ONLY on the frame that the button is first touched</summary>
         public bool TouchDown
@@ -65,15 +65,15 @@ public bool TouchDown
             {
                 if (TouchDownExpired)
                 {
-                    TouchDownCached = InputDevice.GetTouchDown(NVRbutton);
+                    TouchDownCached = (InputDevice != null) ? InputDevice.GetTouchDown(NVRbutton) : false;
                     TouchDownExpired = false;
                 }
                 return TouchDownCached;
             }
         }
 
         private bool TouchDownCached;
-        private bool TouchDownExpired = false;
+        private bool TouchDownExpired = true;
 
         /// <summary>Is true ONLY on the frame that the button is released after being touched</summary>
         public bool TouchUp
@@ -82,15 +82,15 @@ public bool TouchUp
             {
                 if (TouchUpExpired)
                 {
-                    TouchUpCached = InputDevice.GetTouchUp(NVRbutton);
+                    TouchUpCached = (InputDevice != null) ? InputDevice.GetTouchUp(NVRbutton) : false;
                     TouchUpExpired = false;
                 }
                 return TouchUpCached;
             }
         }
 
         private bool TouchUpCached;
-        private bool TouchUpExpired = false;
+        private bool TouchUpExpired = true;
 
         /// <summary>Is true WHENEVER the button is being touched</summary>
         public bool IsTouched
@@ -99,15 +99,15 @@ public bool IsTouched
             {
                 if (IsTouchedExpired)
                 {
-                    IsTouchedCached = InputDevice.GetTouch(NVRbutton);
+                    IsTouchedCached = (InputDevice != null) ? InputDevice.GetTouch(NVRbutton) : false;
                     IsTouchedExpired = false;
                 }
                 return IsTouchedCached;
             }
         }
 
         private bool IsTouchedCached;
-        private bool IsTouchedExpired = false;
+        private bool IsTouchedExpired = true;
 
         /// <summary>Is true ONLY on the frame that the button is first near touched</summary>
         public bool NearTouchDown
@@ -116,15 +116,15 @@ public bool NearTouchDown
             {
                 if (NearTouchDownExpired)
                 {
-                    NearTouchDownCached = InputDevice.GetNearTouchDown(NVRbutton);
+                    NearTouchDownCached = (InputDevice != null) ? InputDevice.GetNearTouchDown(NVRbutton) : false;
                     NearTouchDownExpired = false;
                 }
                 return NearTouchDownCached;
             }
         }
 
         private bool NearTouchDownCached;
-        private bool NearTouchDownExpired = false;
+        private bool NearTouchDownExpired = true;
 
         /// <summary>Is true ONLY on the frame that the button is released after being near touched</summary>
         public bool NearTouchUp
@@ -133,15 +133,15 @@ public bool NearTouchUp
             {
                 if (NearTouchUpExpired)
                 {
-                    NearTouchUpCached = InputDevice.GetNearTouchUp(NVRbutton);
+                    NearTouchUpCached = (InputDevice != null) ? InputDevice.GetNearTouchUp(NVRbutton) : false;
                     NearTouchUpExpired = false;
                 }
                 return NearTouchUpCached;
             }
         }
 
         private bool NearTouchUpCached;
-        private bool NearTouchUpExpired = false;
+        private bool NearTouchUpExpired = true;
 
         /// <summary>Is true WHENEVER the button is near being touched</summary>
         public bool IsNearTouched
@@ -150,15 +150,15 @@ public bool IsNearTouched
             {
                 if (IsNearTouchedExpired)
                 {
-                    IsNearTouchedCached = InputDevice.GetNearTouch(NVRbutton);
+                    IsNearTouchedCached = (InputDevice != null) ? InputDevice.GetNearTouch(NVRbutton) : false;
                     IsNearTouchedExpired = false;
                 }
                 return IsNearTouchedCached;
             }
         }
 
         private bool IsNearTouchedCached;
-        private bool IsNearTouchedExpired = false;
+        private bool IsNearTouchedExpired = true;
 
         /// <summary>x,y axis generally for the touchpad. trigger uses x</summary>
         public Vector2 Axis
@@ -167,15 +167,15 @@ public Vector2 Axis
             {
                 if (AxisExpired)
                 {
-                    AxisCached = InputDevice.GetAxis2D(NVRbutton);
+                    AxisCached = (InputDevice != null) ? InputDevice.GetAxis2D(NVRbutton) : Vector2.zero;
                     AxisExpired = false;
                 }
                 return AxisCached;
             }
         }
 
         private Vector2 AxisCached;
-        private bool AxisExpired = false;
+        private bool AxisExpired = true;
 
         /// <summary>x axis from Axis</summary>
         public float SingleAxis
@@ -184,15 +184,15 @@ public float SingleAxis
             {
                 if (SingleAxisExpired)
                 {
-                    SingleAxisCached = InputDevice.GetAxis1D(NVRbutton);
+                    SingleAxisCached = (InputDevice != null) ? InputDevice.GetAxis1D(NVRbutton) : 0f;
                     SingleAxisExpired = false;
                 }
                 return SingleAxisCached;
             }
         }
 
         private float SingleAxisCached;
-        private bool SingleAxisExpired = false;
+        private bool SingleAxisExpired = true;
 
         private NVRInputDevice InputDevice;
         private NVRButtons NVRbutton;

Assets/NewtonVR/NVRHand.cs

@@ -40,13 +40,13 @@ public class NVRHand : MonoBehaviour
         [HideInInspector]
         public GameObject CustomPhysicalColliders;
 
-        private VisibilityLevel CurrentVisibility = VisibilityLevel.Visible;
-        private bool VisibilityLocked = false;
+        protected VisibilityLevel CurrentVisibility = VisibilityLevel.Visible;
+        protected bool VisibilityLocked = false;
 
         [HideInInspector]
         public HandState CurrentHandState = HandState.Uninitialized;
 
-        private Dictionary<NVRInteractable, Dictionary<Collider, float>> CurrentlyHoveringOver;
+        protected Dictionary<NVRInteractable, Dictionary<Collider, float>> CurrentlyHoveringOver;
 
         public NVRInteractable CurrentlyInteracting;
 
@@ -55,22 +55,24 @@ public class NVRInteractableEvent : UnityEvent<NVRInteractable> { }
 
         public NVRInteractableEvent OnBeginInteraction = new NVRInteractableEvent();
         public NVRInteractableEvent OnEndInteraction = new NVRInteractableEvent();
+        public NVRInteractableEvent OnBeginUseInteraction = new NVRInteractableEvent ();
+        public NVRInteractableEvent OnEndUseInteraction = new NVRInteractableEvent ();
 
-        private int EstimationSampleIndex;
-        private Vector3[] LastPositions;
-        private Quaternion[] LastRotations;
-        private float[] LastDeltas;
-        private int EstimationSamples = 5;
+        protected int EstimationSampleIndex;
+        protected Vector3[] LastPositions;
+        protected Quaternion[] LastRotations;
+        protected float[] LastDeltas;
+        protected int EstimationSamples = 5;
 
         [HideInInspector]
         public NVRPhysicalController PhysicalController;
 
-        private Collider[] GhostColliders;
-        private Renderer[] GhostRenderers;
+        protected Collider[] GhostColliders;
+        protected Renderer[] GhostRenderers;
 
-        private NVRInputDevice InputDevice;
+        protected NVRInputDevice InputDevice;
 
-        private GameObject RenderModel;
+        protected GameObject RenderModel;
 
         public bool IsHovering
         {
@@ -356,7 +358,7 @@ protected void UpdateInteractions()
             }
         }
 
-        private void UpdateVisibilityAndColliders()
+        protected void UpdateVisibilityAndColliders()
         {
             if (Player.PhysicalHands == true)
             {
@@ -590,7 +592,7 @@ public virtual void EndInteraction(NVRInteractable item)
             }
         }
 
-        private bool PickupClosest()
+        protected bool PickupClosest()
         {
             NVRInteractable closest = null;
             float closestDistance = float.MaxValue;
@@ -601,6 +603,14 @@ private bool PickupClosest()
                 {
                     if (hovering.Key == null)
                         continue;
+
+                    if (!hovering.Key.gameObject.activeInHierarchy)
+                        continue;
+
+                    var itemColliders = hovering.Value;
+
+                    itemColliders.Where (item => !item.Key.gameObject.activeInHierarchy).ToList ().ForEach (item => itemColliders.Remove (item.Key));
+
 
                     float distance = Vector3.Distance(collider.transform.position, hovering.Key.transform.position);
                     if (distance < closestDistance)
@@ -621,12 +631,45 @@ private bool PickupClosest()
                 return false;
             }
         }
+
+        protected bool PickupByName(string withName)
+        {
+            NVRInteractable closest = null;
+            float closestDistance = float.MaxValue;
+
+
+            foreach (var hovering in CurrentlyHoveringOver)
+            {
+                if (hovering.Key == null)
+                    continue;
+
+                float distance = Vector3.Distance(this.transform.position, hovering.Key.transform.position);
+                if (distance < closestDistance && hovering.Key.name==withName)
+                {
+                    closestDistance = distance;
+                    closest = hovering.Key;
+                }
+            }
+
+            if (closest != null)
+            {
+                BeginInteraction(closest);
+                return true;
+            }
+            else
+            {
+                return false;
+            }
+        }
 
         protected virtual void OnTriggerEnter(Collider collider)
         {
             NVRInteractable interactable = NVRInteractables.GetInteractable(collider);
             if (interactable == null || interactable.enabled == false)
                 return;
+
+	    if (CurrentlyHoveringOver == null)
+	        CurrentlyHoveringOver = new Dictionary<NVRInteractable, Dictionary<Collider, float>> ();
 
             if (CurrentlyHoveringOver.ContainsKey(interactable) == false)
                 CurrentlyHoveringOver[interactable] = new Dictionary<Collider, float>();
@@ -772,7 +815,7 @@ protected void InitializeRenderModel()
             }
         }
 
-        public void Initialize()
+        public virtual void Initialize()
         {
             Rigidbody = this.GetComponent<Rigidbody>();
             if (Rigidbody == null)
@@ -879,4 +922,4 @@ public enum InterationStyle
         Toggle,
         ByScript,
     }
-}
+}

Assets/NewtonVR/NVRHandedInteractableItem.cs

@@ -0,0 +1,26 @@
+using UnityEngine;
+using System.Collections;
+using NewtonVR;
+
+public class NVRHandedInteractableItem : NVRInteractableItem
+{
+	[SerializeField]
+	Transform LeftHandInteractionPoint;
+
+	[SerializeField]
+	Transform RightHandInteractionPoint;
+
+	public override void BeginInteraction (NVRHand hand)
+	{
+		if (hand.IsLeft)
+		{
+			InteractionPoint = LeftHandInteractionPoint;
+		}
+		else
+		{
+			InteractionPoint = RightHandInteractionPoint;
+		}
+
+		base.BeginInteraction (hand);
+	}
+}