Refactor Grabbable/Draggable

* Now BasicGrabbable/StickyGrabbable/Draggable derive from GrabbableBase
* Now Grabbable/Draggable apply PoseModifier when tracking grabber
* Now pointer scroll can extend drag distance when dragging a Draggable item

Author: lawwong

Assets/HTC.UnityPlugin/Utility/Container/IndexedTable.cs

@@ -261,7 +261,7 @@ public void RemoveAll(Predicate<KeyValuePair<TKey, TValue>> match)
                 }
                 else
                 {
-                    if (removed != 0)
+                    if (removed > 0)
                     {
                         m_Dictionary[m_KeyList[i]] = i - removed;
                         m_KeyList[i - removed] = m_KeyList[i];
@@ -270,10 +270,21 @@ public void RemoveAll(Predicate<KeyValuePair<TKey, TValue>> match)
                 }
             }
 
-            for (; removed > 0; --removed)
+            if (removed == 0)
             {
-                m_KeyList.RemoveAt(m_KeyList.Count - 1);
-                m_ValueList.RemoveAt(m_ValueList.Count - 1);
+                return;
+            }
+            else if (removed == Count)
+            {
+                Clear();
+            }
+            else
+            {
+                for (; removed > 0; --removed)
+                {
+                    m_KeyList.RemoveAt(m_KeyList.Count - 1);
+                    m_ValueList.RemoveAt(m_ValueList.Count - 1);
+                }
             }
         }
 

Assets/HTC.UnityPlugin/ViveInputUtility/Examples/3.3DDrag/Scripts/Draggable.cs

@@ -1,11 +1,13 @@
 using HTC.UnityPlugin.Utility;
+using HTC.UnityPlugin.Vive;
 using System;
 using UnityEngine;
 using UnityEngine.Events;
 using UnityEngine.EventSystems;
+using UnityEngine.Serialization;
 
 // demonstrate of dragging things useing built in EventSystem handlers
-public class Draggable : MonoBehaviour
+public class Draggable : GrabbableBase<Draggable.Grabber>
     , IInitializePotentialDragHandler
     , IBeginDragHandler
     , IDragHandler
@@ -14,55 +16,131 @@ public class Draggable : MonoBehaviour
     [Serializable]
     public class UnityEventDraggable : UnityEvent<Draggable> { }
 
-    public const float MIN_FOLLOWING_DURATION = 0.02f;
-    public const float DEFAULT_FOLLOWING_DURATION = 0.04f;
-    public const float MAX_FOLLOWING_DURATION = 0.5f;
+    public class Grabber : IGrabber
+    {
+        private static ObjectPool<Grabber> m_pool;
+
+        public static Grabber Get(PointerEventData eventData)
+        {
+            if (m_pool == null)
+            {
+                m_pool = new ObjectPool<Grabber>(() => new Grabber());
+            }
+
+            var grabber = m_pool.Get();
+            grabber.eventData = eventData;
+            return grabber;
+        }
+
+        public static void Release(Grabber grabber)
+        {
+            grabber.eventData = null;
+            m_pool.Release(grabber);
+        }
+
+        public PointerEventData eventData { get; private set; }
+
+        public RigidPose grabberOrigin
+        {
+            get
+            {
+                var cam = eventData.pointerPressRaycast.module.eventCamera;
+                var ray = cam.ScreenPointToRay(eventData.position);
+                return new RigidPose(ray.origin, Quaternion.LookRotation(ray.direction, cam.transform.up));
+            }
+        }
+
+        public RigidPose grabOffset { get { return grabber2hit * hit2pivot; } set { } }
 
-    private OrderedIndexedTable<PointerEventData, RigidPose> eventList = new OrderedIndexedTable<PointerEventData, RigidPose>();
+        public RigidPose grabber2hit { get; set; }
 
-    public float initGrabDistance = 0.5f;
+        public RigidPose hit2pivot { get; set; }
+
+        public float hitDistance
+        {
+            get { return grabber2hit.pos.z; }
+            set
+            {
+                var p = grabber2hit;
+                p.pos.z = value;
+                grabber2hit = p;
+            }
+        }
+    }
+
+    private IndexedTable<PointerEventData, Grabber> m_eventGrabberSet;
+
+    [FormerlySerializedAs("initGrabDistance")]
+    [SerializeField]
+    private float m_initGrabDistance = 0.5f;
     [Range(MIN_FOLLOWING_DURATION, MAX_FOLLOWING_DURATION)]
-    public float followingDuration = DEFAULT_FOLLOWING_DURATION;
-    public bool overrideMaxAngularVelocity = true;
-    public bool unblockableGrab = true;
+    [FormerlySerializedAs("followingDuration")]
+    [SerializeField]
+    private float m_followingDuration = DEFAULT_FOLLOWING_DURATION;
+    [FormerlySerializedAs("overrideMaxAngularVelocity")]
+    [SerializeField]
+    private bool m_overrideMaxAngularVelocity = true;
+    [FormerlySerializedAs("unblockableGrab")]
+    [SerializeField]
+    private bool m_unblockableGrab = true;
+    [FormerlySerializedAs("afterGrabbed")]
+    [SerializeField]
+    private UnityEventDraggable m_afterGrabbed = new UnityEventDraggable();
+    [FormerlySerializedAs("beforeRelease")]
+    [SerializeField]
+    private UnityEventDraggable m_beforeRelease = new UnityEventDraggable();
+    [FormerlySerializedAs("onDrop")]
+    [SerializeField]
+    private UnityEventDraggable m_onDrop = new UnityEventDraggable(); // change rigidbody drop velocity here
 
-    public UnityEventDraggable afterDragged = new UnityEventDraggable();
-    public UnityEventDraggable beforeRelease = new UnityEventDraggable();
-    public UnityEventDraggable onDrop = new UnityEventDraggable(); // change rigidbody drop velocity here
+    public bool isDragged { get { return isGrabbed; } }
 
-    private RigidPose m_prevPose = RigidPose.identity; // last frame world pose
+    public PointerEventData draggedEvent { get { return isGrabbed ? currentGrabber.eventData : null; } }
 
-    public bool isDragged { get { return eventList.Count > 0; } }
+    public float initGrabDistance { get { return m_initGrabDistance; } set { m_initGrabDistance = value; } }
 
-    public PointerEventData draggedEvent { get { return isDragged ? eventList.GetLastKey() : null; } }
+    public override float followingDuration { get { return m_followingDuration; } set { m_followingDuration = Mathf.Clamp(value, MIN_FOLLOWING_DURATION, MAX_FOLLOWING_DURATION); } }
 
-    // effected rigidbody
-    public Rigidbody rigid { get; set; }
+    public override bool overrideMaxAngularVelocity { get { return m_overrideMaxAngularVelocity; } set { m_overrideMaxAngularVelocity = value; } }
 
-    private bool moveByVelocity { get { return !unblockableGrab && rigid != null && !rigid.isKinematic; } }
+    public bool unblockableGrab { get { return m_unblockableGrab; } set { m_unblockableGrab = value; } }
 
-    private RigidPose GetEventPose(PointerEventData eventData)
+    public UnityEventDraggable afterGrabbed { get { return m_afterGrabbed; } }
+
+    public UnityEventDraggable beforeRelease { get { return m_beforeRelease; } }
+
+    public UnityEventDraggable onDrop { get { return m_onDrop; } }
+
+    private bool moveByVelocity { get { return !unblockableGrab && grabRigidbody != null && !grabRigidbody.isKinematic; } }
+
+    [Obsolete("Use grabRigidbody instead")]
+    public Rigidbody rigid { get { return grabRigidbody; } set { grabRigidbody = value; } }
+
+    protected override void Awake()
     {
-        var cam = eventData.pointerPressRaycast.module.eventCamera;
-        var ray = cam.ScreenPointToRay(eventData.position);
-        return new RigidPose(ray.origin, Quaternion.LookRotation(ray.direction, cam.transform.up));
+        base.Awake();
+
+        afterGrabberGrabbed += () => m_afterGrabbed.Invoke(this);
+        beforeGrabberReleased += () => m_beforeRelease.Invoke(this);
+        onGrabberDrop += () => m_onDrop.Invoke(this);
     }
 
-    protected virtual void Awake()
+    protected virtual void OnDisable()
     {
-        rigid = GetComponent<Rigidbody>();
+        ClearGrabbers(true);
+        ClearEventGrabberSet();
     }
 
-    protected virtual void OnDisable()
+    private void ClearEventGrabberSet()
     {
-        if (isDragged && beforeRelease != null)
+        if (m_eventGrabberSet == null) { return; }
+
+        for (int i = m_eventGrabberSet.Count - 1; i >= 0; --i)
         {
-            beforeRelease.Invoke(this);
+            Grabber.Release(m_eventGrabberSet.GetValueByIndex(i));
         }
 
-        eventList.Clear();
-
-        DoDrop();
+        m_eventGrabberSet.Clear();
     }
 
     public virtual void OnInitializePotentialDrag(PointerEventData eventData)
@@ -72,119 +150,67 @@ public virtual void OnInitializePotentialDrag(PointerEventData eventData)
 
     public virtual void OnBeginDrag(PointerEventData eventData)
     {
-        var casterPose = GetEventPose(eventData);
-        var offsetPose = new RigidPose();
+        var hitDistance = 0f;
+
         switch (eventData.button)
         {
             case PointerEventData.InputButton.Middle:
             case PointerEventData.InputButton.Right:
-                {
-                    var hitResult = eventData.pointerPressRaycast;
-                    var hitPose = new RigidPose(hitResult.worldPosition, casterPose.rot);
-
-                    var caster2hit = new RigidPose(Vector3.forward * Mathf.Min(hitResult.distance, initGrabDistance), Quaternion.identity);
-                    var hit2center = RigidPose.FromToPose(hitPose, new RigidPose(transform));
-
-                    offsetPose = caster2hit * hit2center;
-                    break;
-                }
+                hitDistance = Mathf.Min(eventData.pointerPressRaycast.distance, m_initGrabDistance);
+                break;
             case PointerEventData.InputButton.Left:
+                hitDistance = eventData.pointerPressRaycast.distance;
+                break;
             default:
-                {
-                    offsetPose = RigidPose.FromToPose(casterPose, new RigidPose(transform));
-                    break;
-                }
+                return;
         }
 
-        if (eventData != draggedEvent && beforeRelease != null)
-        {
-            beforeRelease.Invoke(this);
-        }
+        var grabber = Grabber.Get(eventData);
+        grabber.grabber2hit = new RigidPose(new Vector3(0f, 0f, hitDistance), Quaternion.identity);
+        grabber.hit2pivot = RigidPose.FromToPose(grabber.grabberOrigin * grabber.grabber2hit, new RigidPose(transform));
 
-        eventList.AddUniqueKey(eventData, offsetPose);
+        if (m_eventGrabberSet == null) { m_eventGrabberSet = new IndexedTable<PointerEventData, Grabber>(); }
+        m_eventGrabberSet.Add(eventData, grabber);
 
-        if (afterDragged != null)
-        {
-            afterDragged.Invoke(this);
-        }
+        AddGrabber(grabber);
     }
 
     protected virtual void FixedUpdate()
     {
-        if (!isDragged) { return; }
-
-        if (moveByVelocity)
+        if (isGrabbed && moveByVelocity)
         {
-            // if rigidbody exists, follow eventData caster using physics
-            var casterPose = GetEventPose(draggedEvent);
-            var offsetPose = eventList.GetLastValue();
-
-            var targetPose = casterPose * offsetPose;
-            RigidPose.SetRigidbodyVelocity(rigid, rigid.position, targetPose.pos, followingDuration);
-            RigidPose.SetRigidbodyAngularVelocity(rigid, rigid.rotation, targetPose.rot, followingDuration, overrideMaxAngularVelocity);
+            OnGrabRigidbody();
         }
     }
 
-    public virtual void OnDrag(PointerEventData eventData)
+    protected virtual void Update()
     {
-        if (eventData != draggedEvent) { return; }
+        if (!isGrabbed) { return; }
 
         if (!moveByVelocity)
         {
-            // if rigidbody doen't exist, just move transform to eventData caster's pose
-            var casterPose = GetEventPose(eventData);
-            var offsetPose = eventList.GetLastValue();
-
-            m_prevPose = new RigidPose(transform);
-
-            if (rigid != null)
-            {
-                rigid.velocity = Vector3.zero;
-                rigid.angularVelocity = Vector3.zero;
-            }
-
-            var targetPose = casterPose * offsetPose;
-            transform.position = targetPose.pos;
-            transform.rotation = targetPose.rot;
+            RecordLatestPosesForDrop(Time.time, 0.05f);
+            OnGrabTransform();
         }
-    }
 
-    public virtual void OnEndDrag(PointerEventData eventData)
-    {
-        var released = eventData == draggedEvent;
-        if (released && beforeRelease != null)
-        {
-            beforeRelease.Invoke(this);
-        }
-
-        eventList.Remove(eventData);
-
-        if (isDragged)
-        {
-            if (released && afterDragged != null)
-            {
-                afterDragged.Invoke(this);
-            }
-        }
-        else
+        var scrollDelta = currentGrabber.eventData.scrollDelta * 0.01f;
+        if (scrollDelta != Vector2.zero)
         {
-            DoDrop();
+            currentGrabber.hitDistance = Mathf.Max(0f, currentGrabber.hitDistance + scrollDelta.y);
         }
     }
 
-    private void DoDrop()
+    public virtual void OnDrag(PointerEventData eventData) { }
+
+    public virtual void OnEndDrag(PointerEventData eventData)
     {
-        if (!moveByVelocity && rigid != null && !rigid.isKinematic && m_prevPose != RigidPose.identity)
-        {
-            RigidPose.SetRigidbodyVelocity(rigid, m_prevPose.pos, transform.position, Time.deltaTime);
-            RigidPose.SetRigidbodyAngularVelocity(rigid, m_prevPose.rot, transform.rotation, Time.deltaTime, overrideMaxAngularVelocity);
+        if (m_eventGrabberSet == null) { return; }
 
-            m_prevPose = RigidPose.identity;
-        }
+        Grabber grabber;
+        if (!m_eventGrabberSet.TryGetValue(eventData, out grabber)) { return; }
 
-        if (onDrop != null)
-        {
-            onDrop.Invoke(this);
-        }
+        RemoveGrabber(grabber);
+        m_eventGrabberSet.Remove(eventData);
+        Grabber.Release(grabber);
     }
 }