1 files changed, 218 insertions, 160 deletions

diff --git a/OpenSim/Region/Framework/Scenes/KeyframeMotion.cs b/OpenSim/Region/Framework/Scenes/KeyframeMotion.cs
index bbf3b51..bf20c32 100644
--- a/OpenSim/Region/Framework/Scenes/KeyframeMotion.cs
+++ b/OpenSim/Region/Framework/Scenes/KeyframeMotion.cs
@@ -140,7 +140,7 @@ namespace OpenSim.Region.Framework.Scenes
                                 timer.Start();
                         };
                     }
-                    
+
                     // Check again, in case the regions were started while we were adding the event handler
                     if (SceneManager.Instance.AllRegionsReady)
                     {
@@ -292,14 +292,18 @@ namespace OpenSim.Region.Framework.Scenes
 
         private void StartTimer()
         {
-            KeyframeTimer.Add(this);
-            m_timerStopped = false;
+            lock (m_frames)
+            {
+                KeyframeTimer.Add(this);
+                m_lasttickMS = Util.GetTimeStampMS();
+                m_timerStopped = false;
+            }
         }
 
         private void StopTimer()
         {
-            m_timerStopped = true;
-            KeyframeTimer.Remove(this);
+            lock (m_frames)
+                m_timerStopped = true;
         }
 
         public static KeyframeMotion FromData(SceneObjectGroup grp, Byte[] data)
@@ -323,8 +327,8 @@ namespace OpenSim.Region.Framework.Scenes
                         newMotion.m_selected = true;
                 }
 
-                newMotion.m_timerStopped = false;
-                newMotion.m_running = true;
+//                newMotion.m_timerStopped = false;
+//                newMotion.m_running = true;
                 newMotion.m_isCrossing = false;
                 newMotion.m_waitingCrossing = false;
             }
@@ -348,24 +352,26 @@ namespace OpenSim.Region.Framework.Scenes
             m_group = grp;
             m_scene = grp.Scene;
 
-            Vector3 grppos = grp.AbsolutePosition;
-            Vector3 offset = grppos - m_serializedPosition;
-            // avoid doing it more than once
-            // current this will happen dragging a prim to other region
-            m_serializedPosition = grppos;
 
-            m_basePosition += offset;
-            m_nextPosition += offset;
-            
-            m_currentFrame.StartPosition += offset;
-            m_currentFrame.Position += offset;
-
-            for (int i = 0; i < m_frames.Count; i++)
+            lock (m_frames)
             {
-                Keyframe k = m_frames[i];
-                k.StartPosition += offset;
-                k.Position += offset;
-                m_frames[i]=k;
+                Vector3 grppos = grp.AbsolutePosition;
+                Vector3 offset = grppos - m_serializedPosition;
+                // avoid doing it more than once
+                // current this will happen draging a prim to other region
+                m_serializedPosition = grppos;
+
+                m_basePosition += offset;
+                m_currentFrame.Position += offset;
+
+                m_nextPosition += offset;
+
+                for (int i = 0; i < m_frames.Count; i++)
+                {
+                    Keyframe k = m_frames[i];
+                    k.Position += offset;
+                    m_frames[i] = k;
+                }
             }
 
             if (m_running)
@@ -410,25 +416,28 @@ namespace OpenSim.Region.Framework.Scenes
                 m_keyframes.CopyTo(newmotion.m_keyframes, 0);
             }
 
-            newmotion.m_frames = new List<Keyframe>(m_frames);
+            lock (m_frames)
+            {
+                newmotion.m_frames = new List<Keyframe>(m_frames);
 
-            newmotion.m_basePosition = m_basePosition;
-            newmotion.m_baseRotation = m_baseRotation;
+                newmotion.m_basePosition = m_basePosition;
+                newmotion.m_baseRotation = m_baseRotation;
 
-            if (m_selected)
-                newmotion.m_serializedPosition = m_serializedPosition;
-            else
-            {
-                if (m_group != null)
-                    newmotion.m_serializedPosition = m_group.AbsolutePosition;
-                else
+                if (m_selected)
                     newmotion.m_serializedPosition = m_serializedPosition;
-            }
+                else
+                {
+                    if (m_group != null)
+                        newmotion.m_serializedPosition = m_group.AbsolutePosition;
+                    else
+                        newmotion.m_serializedPosition = m_serializedPosition;
+                }
 
-            newmotion.m_currentFrame = m_currentFrame;
+                newmotion.m_currentFrame = m_currentFrame;
 
-            newmotion.m_iterations = m_iterations;
-            newmotion.m_running = m_running;
+                newmotion.m_iterations = m_iterations;
+                newmotion.m_running = m_running;
+            }
 
             if (m_running && !m_waitingCrossing)
                 StartTimer();
@@ -458,39 +467,62 @@ namespace OpenSim.Region.Framework.Scenes
             }
             else
             {
-                m_running = false;
                 StopTimer();
+                m_running = false;
             }
         }
 
         public void Stop()
         {
+            StopTimer();
             m_running = false;
             m_isCrossing = false;
             m_waitingCrossing = false;
 
-            StopTimer();
-
             m_basePosition = m_group.AbsolutePosition;
             m_baseRotation = m_group.GroupRotation;
 
             m_group.RootPart.Velocity = Vector3.Zero;
             m_group.RootPart.AngularVelocity = Vector3.Zero;
-            m_group.SendGroupRootTerseUpdate();
-//            m_group.RootPart.ScheduleTerseUpdate();
+//            m_group.SendGroupRootTerseUpdate();
+            m_group.RootPart.ScheduleTerseUpdate();
             m_frames.Clear();
+            m_group.Scene.EventManager.TriggerMovingEndEvent(m_group.RootPart.LocalId);
         }
 
         public void Pause()
         {
-            m_running = false;
             StopTimer();
+            m_running = false;
 
             m_group.RootPart.Velocity = Vector3.Zero;
             m_group.RootPart.AngularVelocity = Vector3.Zero;
-            m_group.SendGroupRootTerseUpdate();
-//            m_group.RootPart.ScheduleTerseUpdate();
+//            m_skippedUpdates = 1000;
+//            m_group.SendGroupRootTerseUpdate();
+            m_group.RootPart.ScheduleTerseUpdate();
+            m_group.Scene.EventManager.TriggerMovingEndEvent(m_group.RootPart.LocalId);
+        }
+
+        public void Suspend()
+        {
+            lock (m_frames)
+            {
+                if (m_timerStopped)
+                    return;
+                m_timerStopped = true;
+            }
+        }
 
+        public void Resume()
+        {
+            lock (m_frames)
+            {
+                if (!m_timerStopped)
+                    return;
+                if (m_running && !m_waitingCrossing)
+                    StartTimer();
+//                m_skippedUpdates = 1000;
+            }
         }
 
         private void GetNextList()
@@ -581,6 +613,7 @@ namespace OpenSim.Region.Framework.Scenes
 
                     pos = (Vector3)k.Position;
                     rot = (Quaternion)k.Rotation;
+
                 }
 
                 m_basePosition = pos;
@@ -592,27 +625,60 @@ namespace OpenSim.Region.Framework.Scenes
 
         public void OnTimer(double tickDuration)
         {
+            if (!Monitor.TryEnter(m_frames))
+                return;
+            if (m_timerStopped)
+                KeyframeTimer.Remove(this);
+            else
+                DoOnTimer(tickDuration);
+            Monitor.Exit(m_frames);
+        }
+
+        private void Done()
+        {
+            KeyframeTimer.Remove(this);
+            m_timerStopped = true;
+            m_running = false;
+            m_isCrossing = false;
+            m_waitingCrossing = false;
+
+            m_basePosition = m_group.AbsolutePosition;
+            m_baseRotation = m_group.GroupRotation;
+
+            m_group.RootPart.Velocity = Vector3.Zero;
+            m_group.RootPart.AngularVelocity = Vector3.Zero;
+//            m_group.SendGroupRootTerseUpdate();
+            m_group.RootPart.ScheduleTerseUpdate();
+            m_frames.Clear();
+        }
+
+//        [NonSerialized()] Vector3 m_lastPosUpdate;
+//        [NonSerialized()] Quaternion m_lastRotationUpdate;
+        [NonSerialized()] Vector3 m_currentVel;
+//        [NonSerialized()] int m_skippedUpdates;
+        [NonSerialized()] double m_lasttickMS;
+
+        private void DoOnTimer(double tickDuration)
+        {
             if (m_skipLoops > 0)
             {
                 m_skipLoops--;
                 return;
             }
 
-            if (m_timerStopped) // trap events still in air even after a timer.stop
-                return;
-
             if (m_group == null)
                 return;
 
-            bool update = false;
+//            bool update = false;
 
             if (m_selected)
             {
                 if (m_group.RootPart.Velocity != Vector3.Zero)
                 {
                     m_group.RootPart.Velocity = Vector3.Zero;
-                    m_group.SendGroupRootTerseUpdate();
-
+//                    m_skippedUpdates = 1000;
+//                    m_group.SendGroupRootTerseUpdate();
+                    m_group.RootPart.ScheduleTerseUpdate();
                 }
                 return;
             }
@@ -624,7 +690,9 @@ namespace OpenSim.Region.Framework.Scenes
                 // retry to set the position that evtually caused the outbound
                 // if still outside region this will call startCrossing below
                 m_isCrossing = false;
+//                m_skippedUpdates = 1000;
                 m_group.AbsolutePosition = m_nextPosition;
+
                 if (!m_isCrossing)
                 {
                     StopTimer();
@@ -633,43 +701,43 @@ namespace OpenSim.Region.Framework.Scenes
                 return;
             }
 
+            double nowMS = Util.GetTimeStampMS();
+
             if (m_frames.Count == 0)
             {
-                if (!m_running) return;
+                lock (m_frames)
+                {
+                    GetNextList();
 
-                GetNextList();
+                    if (m_frames.Count == 0)
+                    {
+                        Done();
+                        m_group.Scene.EventManager.TriggerMovingEndEvent(m_group.RootPart.LocalId);
+                        return;
+                    }
 
-                if (m_frames.Count == 0)
-                {
-                    Stop();
-//                    Scene scene = m_group.Scene;
-//
-//                    IScriptModule[] scriptModules = scene.RequestModuleInterfaces<IScriptModule>();
-//                    foreach (IScriptModule m in scriptModules)
-//                    {
-//                        if (m == null)
-//                            continue;
-//                        m.PostObjectEvent(m_group.RootPart.UUID, "moving_end", new object[0]);
-//                    }
-
-                    m_group.Scene.EventManager.TriggerMovingEndEvent(m_group.RootPart.LocalId);
-                        
-                    return;
+                    m_currentFrame = m_frames[0];
                 }
+                m_nextPosition = m_group.AbsolutePosition;
+                m_currentVel = (Vector3)m_currentFrame.Position - m_nextPosition;
+                m_currentVel /= (m_currentFrame.TimeMS * 0.001f);
 
-                m_currentFrame = m_frames[0];
                 m_currentFrame.TimeMS += (int)tickDuration;
-
-                //force a update on a keyframe transition
-                update = true;
+                m_lasttickMS = nowMS - 50f;
+//                update = true;
             }
 
-            m_currentFrame.TimeMS -= (int)tickDuration;
+            int elapsed = (int)(nowMS - m_lasttickMS);
+            if( elapsed > 3 * tickDuration)
+                elapsed = (int)tickDuration;
+
+            m_currentFrame.TimeMS -= elapsed;
+            m_lasttickMS = nowMS;
 
             // Do the frame processing
             double remainingSteps = (double)m_currentFrame.TimeMS / tickDuration;
 
-            if (remainingSteps <= 0.0)
+            if (remainingSteps <= 1.0)
             {
                 m_group.RootPart.Velocity = Vector3.Zero;
                 m_group.RootPart.AngularVelocity = Vector3.Zero;
@@ -677,111 +745,99 @@ namespace OpenSim.Region.Framework.Scenes
                 m_nextPosition = (Vector3)m_currentFrame.Position;
                 m_group.AbsolutePosition = m_nextPosition;
 
-                // we are sending imediate updates, no doing force a extra terseUpdate
-                // m_group.UpdateGroupRotationR((Quaternion)m_currentFrame.Rotation);
-
                 m_group.RootPart.RotationOffset = (Quaternion)m_currentFrame.Rotation;
-                m_frames.RemoveAt(0);
-                if (m_frames.Count > 0)
-                    m_currentFrame = m_frames[0];
 
-                update = true;
+                lock (m_frames)
+                {
+                    m_frames.RemoveAt(0);
+                    if (m_frames.Count > 0)
+                    {
+                        m_currentFrame = m_frames[0];
+                        m_currentVel = (Vector3)m_currentFrame.Position - m_nextPosition;
+                        m_currentVel /= (m_currentFrame.TimeMS * 0.001f);
+                        m_group.RootPart.Velocity = m_currentVel;
+                        m_currentFrame.TimeMS += (int)tickDuration;
+                    }
+                    else
+                        m_group.RootPart.Velocity = Vector3.Zero;
+                }
+//                update = true;
             }
             else
             {
-                float completed = ((float)m_currentFrame.TimeTotal - (float)m_currentFrame.TimeMS) / (float)m_currentFrame.TimeTotal;
-                bool lastStep = m_currentFrame.TimeMS <= tickDuration;
-
-                Vector3 positionThisStep = m_currentFrame.StartPosition + (m_currentFrame.Position.Value - m_currentFrame.StartPosition) * completed;
-                Vector3 motionThisStep = positionThisStep - m_group.AbsolutePosition;
-
-                float mag = Vector3.Mag(motionThisStep);
-
-                if ((mag >= 0.02f) || lastStep)
+//                bool lastSteps = remainingSteps < 4;
+        
+                Vector3 currentPosition = m_group.AbsolutePosition;
+                Vector3 motionThisFrame = (Vector3)m_currentFrame.Position - currentPosition;
+                motionThisFrame /= (float)remainingSteps;
+ 
+                m_nextPosition = currentPosition + motionThisFrame;
+
+                Quaternion currentRotation = m_group.GroupRotation;
+                if ((Quaternion)m_currentFrame.Rotation != currentRotation)
                 {
-                    m_nextPosition = m_group.AbsolutePosition + motionThisStep;
-                    m_group.AbsolutePosition = m_nextPosition;
-                    update = true;
-                }
-
-                //int totalSteps = m_currentFrame.TimeTotal / (int)tickDuration;
-                //m_log.DebugFormat("KeyframeMotion.OnTimer: step {0}/{1}, curPosition={2}, finalPosition={3}, motionThisStep={4} (scene {5})",
-                //    totalSteps - remainingSteps + 1, totalSteps, m_group.AbsolutePosition, m_currentFrame.Position, motionThisStep, m_scene.RegionInfo.RegionName);
-
-                if ((Quaternion)m_currentFrame.Rotation != m_group.GroupRotation)
-                {
-                    Quaternion current = m_group.GroupRotation;
-
+                    float completed = ((float)m_currentFrame.TimeTotal - (float)m_currentFrame.TimeMS) / (float)m_currentFrame.TimeTotal;
                     Quaternion step = Quaternion.Slerp(m_currentFrame.StartRotation, (Quaternion)m_currentFrame.Rotation, completed);
                     step.Normalize();
-/* use simpler change detection
-* float angle = 0;
-
-                    float aa = current.X * current.X + current.Y * current.Y + current.Z * current.Z + current.W * current.W;
-                    float bb = step.X * step.X + step.Y * step.Y + step.Z * step.Z + step.W * step.W;
-                    float aa_bb = aa * bb;
-
-                    if (aa_bb == 0)
-                    {
-                        angle = 0;
-                    }
-                    else
-                    {
-                        float ab = current.X * step.X +
-                                   current.Y * step.Y +
-                                   current.Z * step.Z +
-                                   current.W * step.W;
-                        float q = (ab * ab) / aa_bb;
-
-                        if (q > 1.0f)
-                        {
-                            angle = 0;
-                        }
-                        else
-                        {
-                            angle = (float)Math.Acos(2 * q - 1);
-                        }
-                    }
-
-                    if (angle > 0.01f)
-*/
-                    if(Math.Abs(step.X - current.X) > 0.001f 
-                        || Math.Abs(step.Y - current.Y) > 0.001f 
-                        || Math.Abs(step.Z - current.Z) > 0.001f
-                        || lastStep)
-                        // assuming w is a dependente var
-
-                    {
-//                                m_group.UpdateGroupRotationR(step);
-                        m_group.RootPart.RotationOffset = step;
-
-                        //m_group.RootPart.UpdateAngularVelocity(m_currentFrame.AngularVelocity / 2);
+                    m_group.RootPart.RotationOffset = step;
+/*
+                    if (Math.Abs(step.X - m_lastRotationUpdate.X) > 0.001f
+                        || Math.Abs(step.Y - m_lastRotationUpdate.Y) > 0.001f
+                        || Math.Abs(step.Z - m_lastRotationUpdate.Z) > 0.001f)
                         update = true;
-                    }
+*/
                 }
-            }
 
-            if (update)
-            {
-                m_group.SendGroupRootTerseUpdate();
+                m_group.AbsolutePosition = m_nextPosition;
+//                if(lastSteps)
+//                    m_group.RootPart.Velocity = Vector3.Zero;
+//                else
+                    m_group.RootPart.Velocity = m_currentVel;
+/*
+                if(!update && (
+//                    lastSteps ||
+                    m_skippedUpdates * tickDuration > 0.5 ||
+                    Math.Abs(m_nextPosition.X - currentPosition.X) > 5f ||
+                    Math.Abs(m_nextPosition.Y - currentPosition.Y) > 5f ||
+                    Math.Abs(m_nextPosition.Z - currentPosition.Z) > 5f
+                    ))
+                {
+                    update = true;
+                }
+                else
+                    m_skippedUpdates++;
+*/
             }
+//            if(update)
+//            {
+//                m_lastPosUpdate = m_nextPosition;
+//                m_lastRotationUpdate = m_group.GroupRotation; 
+//                m_skippedUpdates = 0;
+//                m_group.SendGroupRootTerseUpdate();
+                m_group.RootPart.ScheduleTerseUpdate();
+//            }
         }
 
         public Byte[] Serialize()
         {
+            bool timerWasStopped;
+            lock (m_frames)
+            {
+                timerWasStopped = m_timerStopped;
+            }
             StopTimer();
 
             SceneObjectGroup tmp = m_group;
             m_group = null;
-            if (!m_selected && tmp != null)
-                m_serializedPosition = tmp.AbsolutePosition;
 
             using (MemoryStream ms = new MemoryStream())
             {
                 BinaryFormatter fmt = new BinaryFormatter();
+                if (!m_selected && tmp != null)
+                    m_serializedPosition = tmp.AbsolutePosition;
                 fmt.Serialize(ms, this);
                 m_group = tmp;
-                if (m_running && !m_waitingCrossing)
+                if (!timerWasStopped && m_running && !m_waitingCrossing)
                     StartTimer();
 
                 return ms.ToArray();
@@ -791,10 +847,10 @@ namespace OpenSim.Region.Framework.Scenes
         public void StartCrossingCheck()
         {
             // timer will be restart by crossingFailure
-            // or never since crossing worked and this 
+            // or never since crossing worked and this
             // should be deleted
             StopTimer();
-           
+
             m_isCrossing = true;
             m_waitingCrossing = true;
 
@@ -802,8 +858,9 @@ namespace OpenSim.Region.Framework.Scenes
             if (m_group.RootPart.Velocity != Vector3.Zero)
             {
                 m_group.RootPart.Velocity = Vector3.Zero;
-                m_group.SendGroupRootTerseUpdate();
-//                m_group.RootPart.ScheduleTerseUpdate();
+//                m_skippedUpdates = 1000;
+//                m_group.SendGroupRootTerseUpdate();
+                m_group.RootPart.ScheduleTerseUpdate();
             }
         }
 
@@ -814,8 +871,9 @@ namespace OpenSim.Region.Framework.Scenes
             if (m_group != null)
             {
                 m_group.RootPart.Velocity = Vector3.Zero;
-                m_group.SendGroupRootTerseUpdate();
-//                m_group.RootPart.ScheduleTerseUpdate();
+//                m_skippedUpdates = 1000;
+//                m_group.SendGroupRootTerseUpdate();
+                m_group.RootPart.ScheduleTerseUpdate();
 
                 if (m_running)
                 {