Implement client side interpolation for SyncPose

Author: clku

Assets/Prototypes/1-Viewing/Scenes/Viewing-PC.unity

@@ -12,7 +12,7 @@ public class ViveShare_SyncBase : MonoBehaviour
         protected ViveShare_SyncIdentity identity;
 
         // sync message send interval
-        public float sendInterval = 0.011f;
+        public float sendInterval = 0.1f;
         private float lastSendTime = 0.0f;
 
         public virtual void OnEnable()

Assets/Prototypes/Common/Scripts/ViveShare/ParamSync/ViveShare_SyncBase.cs

@@ -1,35 +1,46 @@
 //========= Copyright 2017, HTC Corporation. All rights reserved. ===========
 
+using System.Collections.Generic;
 using UnityEngine;
 
 namespace HTC.UnityPlugin.ViveShare
 {
     public class ViveShare_SyncPose : ViveShare_SyncBase
     {
-        // transform from network
-        private float currTimeStamp = 0;
-        private Vector3 currPosition = Vector3.zero;
-        private Vector3 currEulerRotation = Vector3.zero;
+        private class State
+        {
+            public float timeStamp;
+            public Vector3 position;
+            public Quaternion rotation;
+        }
+
+        private float lastSyncTime = 0;
+        public bool doInterpolate = true;
+        private float interpolateStep = 0.0f;
+
+        private List<State> states = new List<State>();
 
         //-----------------------------------------------------------------------------
         // state update
         //-----------------------------------------------------------------------------
 
-        public override void OnEnable()
-        {
-            base.OnEnable();
-
-            currPosition = transform.position;
-            currEulerRotation = transform.eulerAngles;
-        }
-
         public void FixedUpdate()
         {
-            // update pose if this object has no authority
-            if (identity.hasAuthority == false)
+            // return if this object has authority
+            if (identity.hasAuthority)
+                return;
+
+            if (doInterpolate && states.Count >= 2)
             {
-                transform.position = currPosition;
-                transform.eulerAngles = currEulerRotation;
+                transform.position = Vector3.Lerp(states[0].position, states[1].position, interpolateStep);
+                transform.rotation = Quaternion.Slerp(states[0].rotation, states[1].rotation, interpolateStep);
+
+                interpolateStep += sendInterval / Time.fixedDeltaTime;
+                if(interpolateStep >= 1)
+                {
+                    interpolateStep = 0;
+                    states.RemoveAt(0);
+                }
             }
         }
 
@@ -39,16 +50,37 @@ public void FixedUpdate()
 
         public override object[] GenerateParamList()
         {
-            object[] param = { transform.position, transform.eulerAngles };
+            object[] param = { transform.position, transform.rotation };
             return param;
         }
 
         public override void SetParams(float timeStamp, object[] paramList)
         {
-            // record newly received state
-            currTimeStamp = timeStamp;
-            currPosition = (Vector3)paramList[0];
-            currEulerRotation = (Vector3)paramList[1];
+            // ignore out-of-order packets
+            if (timeStamp <= lastSyncTime)
+            {
+                return;
+            }
+
+            Vector3 pos = (Vector3)paramList[0];
+            Quaternion rot = (Quaternion)paramList[1];
+
+            if(!doInterpolate)
+            {
+                transform.position = pos;
+                transform.rotation = rot;
+            }
+            else
+            {
+                State newState = new State();
+                newState.timeStamp = timeStamp;
+                newState.position = pos;
+                newState.rotation = rot;
+
+                states.Add(newState);
+            }
+
+            lastSyncTime = timeStamp;
         }
     }
 }