1 files changed, 164 insertions, 116 deletions

diff --git a/OpenSim/Region/Framework/Scenes/KeyframeMotion.cs b/OpenSim/Region/Framework/Scenes/KeyframeMotion.cs
index bbf3b51..cdd8d2d 100644
--- a/OpenSim/Region/Framework/Scenes/KeyframeMotion.cs
+++ b/OpenSim/Region/Framework/Scenes/KeyframeMotion.cs
@@ -292,14 +292,17 @@ namespace OpenSim.Region.Framework.Scenes
 
         private void StartTimer()
         {
-            KeyframeTimer.Add(this);
-            m_timerStopped = false;
+            lock (m_frames)
+            {
+                KeyframeTimer.Add(this);
+                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)
@@ -348,24 +351,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 +415,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,19 +466,18 @@ 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;
 
@@ -483,14 +490,34 @@ namespace OpenSim.Region.Framework.Scenes
 
         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();
+        }
 
+        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();
+            }
         }
 
         private void GetNextList()
@@ -581,6 +608,7 @@ namespace OpenSim.Region.Framework.Scenes
 
                     pos = (Vector3)k.Position;
                     rot = (Quaternion)k.Rotation;
+
                 }
 
                 m_basePosition = pos;
@@ -592,15 +620,41 @@ 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();
+        }
+
+        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;
 
@@ -612,7 +666,6 @@ namespace OpenSim.Region.Framework.Scenes
                 {
                     m_group.RootPart.Velocity = Vector3.Zero;
                     m_group.SendGroupRootTerseUpdate();
-
                 }
                 return;
             }
@@ -635,32 +688,22 @@ namespace OpenSim.Region.Framework.Scenes
 
             if (m_frames.Count == 0)
             {
-                if (!m_running) return;
-
-                GetNextList();
-
-                if (m_frames.Count == 0)
+                lock (m_frames)
                 {
-                    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;
-                }
+                    GetNextList();
 
-                m_currentFrame = m_frames[0];
-                m_currentFrame.TimeMS += (int)tickDuration;
+                    if (m_frames.Count == 0)
+                    {
+                        Done();
+                        m_group.Scene.EventManager.TriggerMovingEndEvent(m_group.RootPart.LocalId);
+                        return;
+                    }
 
+                    m_currentFrame = m_frames[0];
+                    m_currentFrame.TimeMS += (int)tickDuration;
+                }
                 //force a update on a keyframe transition
+                m_nextPosition = m_group.AbsolutePosition;
                 update = true;
             }
 
@@ -681,9 +724,13 @@ namespace OpenSim.Region.Framework.Scenes
                 // 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];
+
+                lock (m_frames)
+                {
+                    m_frames.RemoveAt(0);
+                    if (m_frames.Count > 0)
+                        m_currentFrame = m_frames[0];
+                }
 
                 update = true;
             }
@@ -692,17 +739,14 @@ namespace OpenSim.Region.Framework.Scenes
                 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;
+                Vector3 v = (Vector3)m_currentFrame.Position - m_group.AbsolutePosition;
+                Vector3 motionThisFrame = v / (float)remainingSteps;
+                v = v * 1000 / m_currentFrame.TimeMS;
 
-                float mag = Vector3.Mag(motionThisStep);
+                m_nextPosition = m_group.AbsolutePosition + motionThisFrame;
 
-                if ((mag >= 0.02f) || lastStep)
-                {
-                    m_nextPosition = m_group.AbsolutePosition + motionThisStep;
-                    m_group.AbsolutePosition = m_nextPosition;
+                if (Vector3.Mag(motionThisFrame) >= 0.05f)
                     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})",
@@ -714,43 +758,41 @@ namespace OpenSim.Region.Framework.Scenes
 
                     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
-
+                    /* 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)
+                    // assuming w is a dependente var
                     {
 //                                m_group.UpdateGroupRotationR(step);
                         m_group.RootPart.RotationOffset = step;
@@ -763,25 +805,31 @@ namespace OpenSim.Region.Framework.Scenes
 
             if (update)
             {
+                m_group.AbsolutePosition = m_nextPosition;
                 m_group.SendGroupRootTerseUpdate();
             }
         }
 
         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();