Now grabbable can be stretched when there're more then 2 grabbers

Must have valid min/maxScaleOnStretch value (min < max)
  or it won't scale (stretch only)
Must enable "multiple grabbers" option

Author: lawwong

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

@@ -53,11 +53,11 @@ public override RigidPose grabberOrigin
             {
                 var cam = eventData.pointerPressRaycast.module.eventCamera;
                 var ray = cam.ScreenPointToRay(eventData.position);
-                return new RigidPose(ray.origin, Quaternion.LookRotation(ray.direction, cam.transform.up));
+                return new RigidPose(ray.origin, Quaternion.LookRotation(ray.direction, cam.transform.up)) * grabber2hit;
             }
         }
 
-        public override RigidPose grabOffset { get { return grabber2hit * hit2pivot; } set { hit2pivot = grabber2hit.GetInverse() * value; } }
+        public override RigidPose grabOffset { get { return hit2pivot; } set { hit2pivot = value; } }
 
         public RigidPose grabber2hit { get; set; }
 
@@ -94,6 +94,10 @@ public float hitDistance
     [SerializeField]
     [FormerlySerializedAs("m_scrollDelta")]
     private float m_scrollingSpeed = 0.01f;
+    [SerializeField]
+    private float m_minStretchScale = 1f;
+    [SerializeField]
+    private float m_maxStretchScale = 1f;
     [FormerlySerializedAs("afterGrabbed")]
     [SerializeField]
     private UnityEventDraggable m_afterGrabbed = new UnityEventDraggable();
@@ -116,6 +120,10 @@ public float hitDistance
 
     public bool unblockableGrab { get { return m_unblockableGrab; } set { m_unblockableGrab = value; } }
 
+    public override float minScaleOnStretch { get { return m_minStretchScale; } set { m_minStretchScale = value; } }
+
+    public override float maxScaleOnStretch { get { return m_maxStretchScale; } set { m_maxStretchScale = value; } }
+
     public UnityEventDraggable afterGrabbed { get { return m_afterGrabbed; } }
 
     public UnityEventDraggable beforeRelease { get { return m_beforeRelease; } }
@@ -189,15 +197,16 @@ public virtual void OnBeginDrag(PointerEventData eventData)
         }
     }
 
+    private static WaitForFixedUpdate waitForFixedUpdate = new WaitForFixedUpdate();
     private IEnumerator PhysicsGrabUpdate()
     {
-        yield return new WaitForFixedUpdate();
+        yield return waitForFixedUpdate;
 
         while (isGrabbed)
         {
             OnGrabRigidbody();
 
-            yield return new WaitForFixedUpdate();
+            yield return waitForFixedUpdate;
         }
 
         yield break;
@@ -209,11 +218,14 @@ private IEnumerator DragUpdate()
 
         while (isGrabbed)
         {
-            var grabber = currentGrabber;
-            var scrollDelta = grabber.eventData.scrollDelta * m_scrollingSpeed;
-            if (scrollDelta != Vector2.zero)
+            for (int i = allGrabbers.Count - 1; i >= 0; --i)
             {
-                grabber.hitDistance = Mathf.Max(0f, grabber.hitDistance + scrollDelta.y);
+                var grabber = allGrabbers.GetValueByIndex(i);
+                var scrollDelta = grabber.eventData.scrollDelta * m_scrollingSpeed;
+                if (scrollDelta != Vector2.zero)
+                {
+                    grabber.hitDistance = Mathf.Max(0f, grabber.hitDistance + scrollDelta.y);
+                }
             }
 
             if (!moveByVelocity)

Assets/HTC.UnityPlugin/ViveInputUtility/Scripts/Misc/BasicGrabbable.cs

@@ -80,6 +80,10 @@ public static void Release(Grabber grabber)
         private bool m_allowMultipleGrabbers = true;
         [SerializeField]
         private bool m_grabOnLastEntered = false;
+        [SerializeField]
+        private float m_minStretchScale = 1f;
+        [SerializeField]
+        private float m_maxStretchScale = 1f;
         [FormerlySerializedAs("afterGrabbed")]
         [SerializeField]
         private UnityEventGrabbable m_afterGrabbed = new UnityEventGrabbable();
@@ -98,6 +102,10 @@ public static void Release(Grabber grabber)
 
         public bool grabOnLastEntered { get { return m_grabOnLastEntered; } set { m_grabOnLastEntered = value; } }
 
+        public override float minScaleOnStretch { get { return m_minStretchScale; } set { m_minStretchScale = value; } }
+
+        public override float maxScaleOnStretch { get { return m_maxStretchScale; } set { m_maxStretchScale = value; } }
+
         public UnityEventGrabbable afterGrabbed { get { return m_afterGrabbed; } }
 
         public UnityEventGrabbable beforeRelease { get { return m_beforeRelease; } }

Assets/HTC.UnityPlugin/ViveInputUtility/Scripts/Misc/GrabbableBase.cs

@@ -40,6 +40,8 @@ private struct PoseSample
         public abstract bool isGrabbed { get; }
         public abstract bool isChangingGrabber { get; }
         public abstract GrabberBase currentGrabberBase { get; }
+        public abstract float minScaleOnStretch { get; set; }
+        public abstract float maxScaleOnStretch { get; set; }
         public Rigidbody grabRigidbody { get; protected set; }
 
         private Queue<PoseSample> m_poseSamples = new Queue<PoseSample>();
@@ -63,32 +65,6 @@ protected void RecordLatestPosesForDrop(float currentTime, float recordLength)
             });
         }
 
-        protected virtual void OnGrabRigidbody()
-        {
-            var currentGrabber = currentGrabberBase;
-            var targetPose = currentGrabber.grabberOrigin * currentGrabber.grabOffset;
-            ModifyPose(ref targetPose, true);
-
-            RigidPose.SetRigidbodyVelocity(grabRigidbody, grabRigidbody.position, targetPose.pos, followingDuration);
-            RigidPose.SetRigidbodyAngularVelocity(grabRigidbody, grabRigidbody.rotation, targetPose.rot, followingDuration, overrideMaxAngularVelocity);
-        }
-
-        protected virtual void OnGrabTransform()
-        {
-            var currentGrabber = currentGrabberBase;
-            var targetPose = currentGrabber.grabberOrigin * currentGrabber.grabOffset;
-            ModifyPose(ref targetPose, true);
-
-            if (grabRigidbody != null)
-            {
-                grabRigidbody.velocity = Vector3.zero;
-                grabRigidbody.angularVelocity = Vector3.zero;
-            }
-
-            transform.position = targetPose.pos;
-            transform.rotation = targetPose.rot;
-        }
-
         protected virtual void DoDrop()
         {
             if (grabRigidbody != null && !grabRigidbody.isKinematic && m_poseSamples.Count > 0)
@@ -102,6 +78,82 @@ protected virtual void DoDrop()
                 m_poseSamples.Clear();
             }
         }
+
+        protected abstract void OnGrabRigidbody();
+
+        protected abstract void OnGrabTransform();
+
+        public struct StretchAnchors
+        {
+            // A1: first anchor
+            // A2: second anchor
+            // C: strethable center
+            // P: closest point on line A1-A2 away from C
+            private Vector3 originScale;
+            private float A1A2Len;
+            private float A1PLen;
+            private float PCLen;
+            private Quaternion originRotOffset;
+            private Quaternion lastRot;
+
+            public void SetupStartingAnchors(Vector3 anchor1, Vector3 anchor2, Vector3 originPos, Quaternion originRot, Vector3 originScale)
+            {
+                // FIXME: what if anchor1 == anchor2?
+                this.originScale = originScale;
+
+                var vectorS1S2 = anchor2 - anchor1;
+                A1A2Len = Vector3.Magnitude(vectorS1S2);
+
+                var vectorS1C = originPos - anchor1;
+                A1PLen = Vector3.Dot(vectorS1C, vectorS1S2) / A1A2Len;
+                PCLen = Mathf.Sqrt(vectorS1C.sqrMagnitude - A1PLen * A1PLen);
+
+                var normal = Vector3.Cross(vectorS1S2, vectorS1C);
+                var rot = Quaternion.LookRotation(vectorS1S2, normal);
+                originRotOffset = Quaternion.Inverse(rot) * originRot;
+
+                lastRot = rot;
+            }
+
+            public void UpdateAnchors(Vector3 anchor1, Vector3 anchor2, out Vector3 newPos, out Quaternion newRot, out Vector3 newScale, float minScale, float maxScale)
+            {
+                // determin scale ratio
+                var vectorS1S2 = anchor2 - anchor1;
+                var vectorS1S2Len = vectorS1S2.magnitude;
+                var vectorS1S2Norm = vectorS1S2 / vectorS1S2Len;
+                var posScale = vectorS1S2Len / A1A2Len;
+
+                lastRot = Quaternion.FromToRotation(lastRot * Vector3.forward, vectorS1S2Norm) * lastRot;
+                var tangent = lastRot * Vector3.right;
+
+                var transformScale = 1f;
+                minScale = Mathf.Abs(minScale);
+                maxScale = Mathf.Abs(maxScale);
+                if (minScale < maxScale)
+                {
+                    // FIXME: what if originScale have zero value?
+                    var originScaleAbs = new Vector3(Mathf.Abs(originScale.x), Mathf.Abs(originScale.y), Mathf.Abs(originScale.z));
+                    if (originScaleAbs.x == originScaleAbs.y && originScaleAbs.y == originScaleAbs.z)
+                    {
+                        transformScale = Mathf.Clamp(posScale, minScale / originScaleAbs.x, maxScale / originScaleAbs.x);
+                    }
+                    else
+                    {
+                        // when scale is irregular, clamp the scale factor to make sure no scale value is out of min/max range
+                        var minScaleAxis = Mathf.Min(originScaleAbs.x, originScaleAbs.y, originScaleAbs.z);
+                        var maxScaleAxis = Mathf.Max(originScaleAbs.x, originScaleAbs.y, originScaleAbs.z);
+                        if (minScaleAxis / maxScaleAxis >= minScale / maxScale)
+                        {
+                            transformScale = Mathf.Clamp(posScale, minScale / minScaleAxis, maxScale / maxScaleAxis);
+                        }
+                    }
+                }
+
+                newPos = anchor1 + vectorS1S2Norm * A1PLen * posScale + tangent * PCLen * transformScale;
+                newRot = lastRot * originRotOffset;
+                newScale = originScale * transformScale;
+            }
+        }
     }
 
     public abstract class GrabbableBase<TEventData, TGrabber> : GrabbableBase where TGrabber : GrabberBase<TEventData> where TEventData : BaseEventData
@@ -119,6 +171,10 @@ public abstract class GrabbableBase<TEventData, TGrabber> : GrabbableBase where
         public event Action beforeGrabberReleased; // get grabber that about to release here
         public event Action onGrabberDrop; // manually change drop velocity here
 
+        private TGrabber anchorGabber1;
+        private TGrabber anchorGabber2;
+        private StretchAnchors stretchAnchors;
+
         protected bool IsGrabberExists(TEventData eventData)
         {
             return m_grabbers.ContainsKey(eventData);
@@ -129,6 +185,35 @@ protected bool TryGetExistsGrabber(TEventData eventData, out TGrabber grabber)
             return m_grabbers.TryGetValue(eventData, out grabber);
         }
 
+        protected bool TryGetValidAnchors(out TGrabber grabber1, out TGrabber grabber2, out Vector3 pose1, out Vector3 pose2)
+        {
+            var i = m_grabbers.Count - 1;
+            if (i >= 1)
+            {
+                var g1 = m_grabbers.GetValueByIndex(i);
+                var p1 = g1.grabberOrigin.pos;
+                for (--i; i >= 0; --i)
+                {
+                    var g2 = m_grabbers.GetValueByIndex(i);
+                    var p2 = g2.grabberOrigin.pos;
+                    if (!Mathf.Approximately((p2 - p1).magnitude, 0f))
+                    {
+                        grabber1 = g1;
+                        grabber2 = g2;
+                        pose1 = p1;
+                        pose2 = p2;
+                        return true;
+                    }
+                }
+            }
+
+            grabber1 = default(TGrabber);
+            grabber2 = default(TGrabber);
+            pose1 = default(Vector3);
+            pose2 = default(Vector3);
+            return false;
+        }
+
         protected abstract TGrabber CreateGrabber(TEventData eventData);
 
         protected abstract void DestoryGrabber(TGrabber grabber);
@@ -146,6 +231,18 @@ protected bool AddGrabber(TEventData eventData)
 
                 if (isGrabbed) { beforeGrabberReleased(); }
                 m_grabbers.Add(eventData, newGrabber);
+
+                Vector3 p1, p2;
+                if (TryGetValidAnchors(out anchorGabber1, out anchorGabber2, out p1, out p2))
+                {
+                    stretchAnchors.SetupStartingAnchors(
+                        p1,
+                        p2,
+                        transform.position,
+                        transform.rotation,
+                        transform.localScale);
+                }
+
                 afterGrabberGrabbed();
                 return true;
             }
@@ -177,6 +274,21 @@ protected bool RemoveGrabber(TEventData eventData)
                 finally { ExitGrabberChangingLock(); }
             }
 
+            Vector3 p1, p2;
+            if (TryGetValidAnchors(out anchorGabber1, out anchorGabber2, out p1, out p2))
+            {
+                stretchAnchors.SetupStartingAnchors(
+                    p1,
+                    p2,
+                    transform.position,
+                    transform.rotation,
+                    transform.localScale);
+            }
+            else if (m_grabbers.Count > 0)
+            {
+                currentGrabber.grabOffset = currentGrabber.grabberOrigin.GetInverse() * new RigidPose(transform);
+            }
+
             return true;
         }
 
@@ -216,9 +328,83 @@ private void ExitGrabberChangingLock()
         {
             m_grabberChangingLock = false;
         }
+
+        protected override void OnGrabRigidbody()
+        {
+            if (anchorGabber1 != null && anchorGabber2 != null)
+            {
+                Vector3 pos;
+                Quaternion rot;
+                Vector3 scale;
+                stretchAnchors.UpdateAnchors(
+                    anchorGabber1.grabberOrigin.pos,
+                    anchorGabber2.grabberOrigin.pos,
+                    out pos,
+                    out rot,
+                    out scale,
+                    minScaleOnStretch,
+                    maxScaleOnStretch);
+
+                GrabRigidbodyToPose(new RigidPose(pos, rot));
+                transform.localScale = scale;
+            }
+            else
+            {
+                var currentGrabber = currentGrabberBase;
+                GrabRigidbodyToPose(currentGrabber.grabberOrigin * currentGrabber.grabOffset);
+            }
+        }
+
+        protected override void OnGrabTransform()
+        {
+            if (anchorGabber1 != null && anchorGabber2 != null)
+            {
+                Vector3 pos;
+                Quaternion rot;
+                Vector3 scale;
+                stretchAnchors.UpdateAnchors(
+                    anchorGabber1.grabberOrigin.pos,
+                    anchorGabber2.grabberOrigin.pos,
+                    out pos,
+                    out rot,
+                    out scale,
+                    minScaleOnStretch,
+                    maxScaleOnStretch);
+
+                GrabTransformToPose(new RigidPose(pos, rot));
+                transform.localScale = scale;
+            }
+            else
+            {
+                var currentGrabber = currentGrabberBase;
+                GrabTransformToPose(currentGrabber.grabberOrigin * currentGrabber.grabOffset);
+            }
+        }
+
+        protected void GrabRigidbodyToPose(RigidPose targetPose)
+        {
+            ModifyPose(ref targetPose, true);
+
+            RigidPose.SetRigidbodyVelocity(grabRigidbody, grabRigidbody.position, targetPose.pos, followingDuration);
+            RigidPose.SetRigidbodyAngularVelocity(grabRigidbody, grabRigidbody.rotation, targetPose.rot, followingDuration, overrideMaxAngularVelocity);
+        }
+
+        protected void GrabTransformToPose(RigidPose targetPose)
+        {
+            ModifyPose(ref targetPose, true);
+
+            if (grabRigidbody != null)
+            {
+                grabRigidbody.velocity = Vector3.zero;
+                grabRigidbody.angularVelocity = Vector3.zero;
+            }
+
+            transform.position = targetPose.pos;
+            transform.rotation = targetPose.rot;
+        }
     }
 
-    [Obsolete("Use GrabbableBase.Generic<TGrabber> instead")]
+    [Obsolete("Use GrabbableBase<TEventData, TGrabber> instead")]
     public abstract class GrabbableBase<TGrabber> : BasePoseTracker where TGrabber : class, GrabbableBase<TGrabber>.IGrabber
     {
         public const float MIN_FOLLOWING_DURATION = 0.02f;