6 files changed, 524 insertions, 270 deletions

diff --git a/OpenSim/Region/Framework/Scenes/KeyframeMotion.cs b/OpenSim/Region/Framework/Scenes/KeyframeMotion.cs
index 5cfba39..b102e48 100644
--- a/OpenSim/Region/Framework/Scenes/KeyframeMotion.cs
+++ b/OpenSim/Region/Framework/Scenes/KeyframeMotion.cs
@@ -22,6 +22,115 @@ using log4net;
 
 namespace OpenSim.Region.Framework.Scenes
 {
+    public class KeyframeTimer
+    {
+        private static Dictionary<Scene, KeyframeTimer>m_timers =
+                new Dictionary<Scene, KeyframeTimer>();
+
+        private Timer m_timer;
+        private Dictionary<KeyframeMotion, object> m_motions = new Dictionary<KeyframeMotion, object>();
+        private object m_lockObject = new object();
+        private object m_timerLock = new object();
+        private const double m_tickDuration = 50.0;
+        private Scene m_scene;
+
+        public double TickDuration
+        {
+            get { return m_tickDuration; }
+        }
+
+        public KeyframeTimer(Scene scene)
+        {
+            m_timer = new Timer();
+            m_timer.Interval = TickDuration;
+            m_timer.AutoReset = true;
+            m_timer.Elapsed += OnTimer;
+
+            m_scene = scene;
+
+            m_timer.Start();
+        }
+
+        private void OnTimer(object sender, ElapsedEventArgs ea)
+        {
+            if (!Monitor.TryEnter(m_timerLock))
+                return;
+
+            try
+            {
+                List<KeyframeMotion> motions;
+
+                lock (m_lockObject)
+                {
+                    motions = new List<KeyframeMotion>(m_motions.Keys);
+                }
+
+                foreach (KeyframeMotion m in motions)
+                {
+                    try
+                    {
+                        m.OnTimer(TickDuration);
+                    }
+                    catch (Exception inner)
+                    {
+                        // Don't stop processing
+                    }
+                }
+            }
+            catch (Exception e)
+            {
+                // Keep running no matter what
+            }
+            finally
+            {
+                Monitor.Exit(m_timerLock);
+            }
+        }
+
+        public static void Add(KeyframeMotion motion)
+        {
+            KeyframeTimer timer;
+
+            if (motion.Scene == null)
+                return;
+
+            lock (m_timers)
+            {
+                if (!m_timers.TryGetValue(motion.Scene, out timer))
+                {
+                    timer = new KeyframeTimer(motion.Scene);
+                    m_timers[motion.Scene] = timer;
+                }
+            }
+
+            lock (timer.m_lockObject)
+            {
+                timer.m_motions[motion] = null;
+            }
+        }
+
+        public static void Remove(KeyframeMotion motion)
+        {
+            KeyframeTimer timer;
+
+            if (motion.Scene == null)
+                return;
+
+            lock (m_timers)
+            {
+                if (!m_timers.TryGetValue(motion.Scene, out timer))
+                {
+                    return;
+                }
+            }
+
+            lock (timer.m_lockObject)
+            {
+                timer.m_motions.Remove(motion);
+            }
+        }
+    }
+
     [Serializable]
     public class KeyframeMotion
     {
@@ -63,18 +172,6 @@ namespace OpenSim.Region.Framework.Scenes
 
         private Keyframe[] m_keyframes;
 
-        [NonSerialized()]
-        protected Timer m_timer = null;
-
-        // timer lock
-        [NonSerialized()]
-        private object m_onTimerLock;
-
-        // timer overrun detect
-        // prevents overlap or timer events threads frozen on the lock
-        [NonSerialized()]
-        private bool m_inOnTimer;
-
         // skip timer events.
         //timer.stop doesn't assure there aren't event threads still being fired
         [NonSerialized()]
@@ -97,12 +194,21 @@ namespace OpenSim.Region.Framework.Scenes
         private DataFormat m_data = DataFormat.Translation | DataFormat.Rotation;
 
         private bool m_running = false;
+
         [NonSerialized()]
         private bool m_selected = false;
 
         private int m_iterations = 0;
 
-        private const double timerInterval = 50.0;
+        private int m_skipLoops = 0;
+
+        [NonSerialized()]
+        private Scene m_scene;
+
+        public Scene Scene
+        {
+            get { return m_scene; }
+        }
 
         public DataFormat Data
         {
@@ -139,31 +245,16 @@ namespace OpenSim.Region.Framework.Scenes
 
         private void StartTimer()
         {
-            if (m_timer == null)
-                return;
+            KeyframeTimer.Add(this);
             m_timerStopped = false;
-            m_timer.Start();
         }
 
         private void StopTimer()
         {
-            if (m_timer == null || m_timerStopped)
-                return;
-            m_timerStopped = true;
-            m_timer.Stop();
-        }
-
-        private void RemoveTimer()
-        {
-            if (m_timer == null)
-                return;
             m_timerStopped = true;
-            m_timer.Stop();
-            m_timer.Elapsed -= OnTimer;
-            m_timer = null;
+            KeyframeTimer.Remove(this);
         }
 
-
         public static KeyframeMotion FromData(SceneObjectGroup grp, Byte[] data)
         {
             KeyframeMotion newMotion = null;
@@ -177,12 +268,15 @@ namespace OpenSim.Region.Framework.Scenes
 
                 newMotion.m_group = grp;
 
-                if (grp != null && grp.IsSelected)
-                    newMotion.m_selected = true;
+                if (grp != null)
+                {
+                    newMotion.m_scene = grp.Scene;
+                    if (grp.IsSelected)
+                        newMotion.m_selected = true;
+                }
 
-                newMotion.m_onTimerLock = new object();
                 newMotion.m_timerStopped = false;
-                newMotion.m_inOnTimer = false;
+                newMotion.m_running = true;
                 newMotion.m_isCrossing = false;
                 newMotion.m_waitingCrossing = false;
             }
@@ -196,37 +290,36 @@ namespace OpenSim.Region.Framework.Scenes
 
         public void UpdateSceneObject(SceneObjectGroup grp)
         {
-//            lock (m_onTimerLock)
-            {
-                m_isCrossing = false;
-                m_waitingCrossing = false;
-                StopTimer();
+            m_isCrossing = false;
+            m_waitingCrossing = false;
+            StopTimer();
 
-                if (grp == null)
-                    return;
+            if (grp == null)
+                return;
 
-                m_group = grp;
-                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_group = grp;
+            m_scene = grp.Scene;
 
-                m_basePosition += offset;
-                m_currentFrame.Position += offset;
+            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_nextPosition += offset;
+            m_basePosition += offset;
+            m_currentFrame.Position += offset;
 
-                for (int i = 0; i < m_frames.Count; i++)
-                {
-                    Keyframe k = m_frames[i];
-                    k.Position += offset;
-                    m_frames[i]=k;
-                }
+            m_nextPosition += offset;
 
-                if (m_running)
-                    Start();
+            for (int i = 0; i < m_frames.Count; i++)
+            {
+                Keyframe k = m_frames[i];
+                k.Position += offset;
+                m_frames[i]=k;
             }
+
+            if (m_running)
+                Start();
         }
 
         public KeyframeMotion(SceneObjectGroup grp, PlayMode mode, DataFormat data)
@@ -239,11 +332,10 @@ namespace OpenSim.Region.Framework.Scenes
             {
                 m_basePosition = grp.AbsolutePosition;
                 m_baseRotation = grp.GroupRotation;
+                m_scene = grp.Scene;
             }
 
-            m_onTimerLock = new object();
             m_timerStopped = true;
-            m_inOnTimer = false;
             m_isCrossing = false;
             m_waitingCrossing = false;
         }
@@ -260,6 +352,7 @@ namespace OpenSim.Region.Framework.Scenes
             KeyframeMotion newmotion = new KeyframeMotion(null, m_mode, m_data);
 
             newmotion.m_group = newgrp;
+            newmotion.m_scene = newgrp.Scene;
 
             if (m_keyframes != null)
             {
@@ -296,7 +389,7 @@ namespace OpenSim.Region.Framework.Scenes
         public void Delete()
         {
             m_running = false;
-            RemoveTimer();
+            StopTimer();
             m_isCrossing = false;
             m_waitingCrossing = false;
             m_frames.Clear();
@@ -309,27 +402,13 @@ namespace OpenSim.Region.Framework.Scenes
             m_waitingCrossing = false;
             if (m_keyframes != null && m_group != null && m_keyframes.Length > 0)
             {
-                if (m_timer == null)
-                {
-                    m_timer = new Timer();
-                    m_timer.Interval = timerInterval;
-                    m_timer.AutoReset = true;
-                    m_timer.Elapsed += OnTimer;
-                }
-                else
-                {
-                    StopTimer();
-                    m_timer.Interval = timerInterval;
-                }
-
-                m_inOnTimer = false;
                 StartTimer();
                 m_running = true;
             }
             else
             {
                 m_running = false;
-                RemoveTimer();
+                StopTimer();
             }
         }
 
@@ -339,7 +418,7 @@ namespace OpenSim.Region.Framework.Scenes
             m_isCrossing = false;
             m_waitingCrossing = false;
 
-            RemoveTimer();
+            StopTimer();
 
             m_basePosition = m_group.AbsolutePosition;
             m_baseRotation = m_group.GroupRotation;
@@ -354,7 +433,7 @@ namespace OpenSim.Region.Framework.Scenes
         public void Pause()
         {
             m_running = false;
-            RemoveTimer();
+            StopTimer();
 
             m_group.RootPart.Velocity = Vector3.Zero;
             m_group.RootPart.AngularVelocity = Vector3.Zero;
@@ -377,15 +456,11 @@ namespace OpenSim.Region.Framework.Scenes
 
                 int start = 0;
                 int end = m_keyframes.Length;
-//                if (m_mode == PlayMode.PingPong && m_keyframes.Length > 1)
-//                    end = m_keyframes.Length - 1;
 
                 if (direction < 0)
                 {
                     start = m_keyframes.Length - 1;
                     end = -1;
-//                    if (m_mode == PlayMode.PingPong && m_keyframes.Length > 1)
-//                        end = 0;
                 }
 
                 for (int i = start; i != end ; i += direction)
@@ -463,189 +538,172 @@ namespace OpenSim.Region.Framework.Scenes
             }
         }
 
-        protected void OnTimer(object sender, ElapsedEventArgs e)
+        public void OnTimer(double tickDuration)
         {
-            if (m_timerStopped) // trap events still in air even after a timer.stop
-                return;
-
-            if (m_inOnTimer) // don't let overruns to happen
+            if (m_skipLoops > 0)
             {
-                m_log.Warn("[KeyFrame]: timer overrun");
+                m_skipLoops--;
                 return;
             }
 
+            if (m_timerStopped) // trap events still in air even after a timer.stop
+                return;
+
             if (m_group == null)
                 return;
 
-            lock (m_onTimerLock)
-            {
+            bool update = false;
 
-                m_inOnTimer = true;
+            if (m_selected)
+            {
+                if (m_group.RootPart.Velocity != Vector3.Zero)
+                {
+                    m_group.RootPart.Velocity = Vector3.Zero;
+                    m_group.SendGroupRootTerseUpdate();
 
-                bool update = false;
+                }
+                return;
+            }
 
-                try
+            if (m_isCrossing)
+            {
+                // if crossing and timer running then cross failed
+                // wait some time then
+                // retry to set the position that evtually caused the outbound
+                // if still outside region this will call startCrossing below
+                m_isCrossing = false;
+                m_group.AbsolutePosition = m_nextPosition;
+                if (!m_isCrossing)
                 {
-                    if (m_selected)
-                    {
-                        if (m_group.RootPart.Velocity != Vector3.Zero)
-                        {
-                            m_group.RootPart.Velocity = Vector3.Zero;
-                            m_group.SendGroupRootTerseUpdate();
-//                            m_group.RootPart.ScheduleTerseUpdate();
+                    StopTimer();
+                    StartTimer();
+                }
+                return;
+            }
 
-                        }
-                        m_inOnTimer = false;
-                        return;
-                    }
+            if (m_frames.Count == 0)
+            {
+                GetNextList();
 
-                    if (m_isCrossing)
-                    {
-                        // if crossing and timer running then cross failed
-                        // wait some time then
-                        // retry to set the position that evtually caused the outbound
-                        // if still outside region this will call startCrossing below
-                        m_isCrossing = false;
-                        m_group.AbsolutePosition = m_nextPosition;
-                        if (!m_isCrossing)
-                        {
-                            StopTimer();
-                            m_timer.Interval = timerInterval;
-                            StartTimer();
-                        }
-                        m_inOnTimer = false;
-                        return;
-                    }
+                if (m_frames.Count == 0)
+                {
+                    Stop();
+                    Scene scene = m_group.Scene;
 
-                    if (m_frames.Count == 0)
+                    IScriptModule[] scriptModules = scene.RequestModuleInterfaces<IScriptModule>();
+                    foreach (IScriptModule m in scriptModules)
                     {
-                        GetNextList();
+                        if (m == null)
+                            continue;
+                        m.PostObjectEvent(m_group.RootPart.UUID, "moving_end", new object[0]);
+                    }
 
-                        if (m_frames.Count == 0)
-                        {
-                            Stop();
-                            m_inOnTimer = false;
-                            return;
-                        }
+                    return;
+                }
 
-                        m_currentFrame = m_frames[0];
-                        m_currentFrame.TimeMS += (int)timerInterval;
+                m_currentFrame = m_frames[0];
+                m_currentFrame.TimeMS += (int)tickDuration;
 
-                        //force a update on a keyframe transition
-                        update = true;
-                    }
+                //force a update on a keyframe transition
+                update = true;
+            }
 
-                    m_currentFrame.TimeMS -= (int)timerInterval;
+            m_currentFrame.TimeMS -= (int)tickDuration;
 
-                    // Do the frame processing
-                    double steps = (double)m_currentFrame.TimeMS / timerInterval;
+            // Do the frame processing
+            double steps = (double)m_currentFrame.TimeMS / tickDuration;
 
-                    if (steps <= 0.0)
-                    {
-                        m_group.RootPart.Velocity = Vector3.Zero;
-                        m_group.RootPart.AngularVelocity = Vector3.Zero;
+            if (steps <= 0.0)
+            {
+                m_group.RootPart.Velocity = Vector3.Zero;
+                m_group.RootPart.AngularVelocity = Vector3.Zero;
 
-                        m_nextPosition = (Vector3)m_currentFrame.Position;
-                        m_group.AbsolutePosition = m_nextPosition;
+                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);
+                // 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];
+                m_group.RootPart.RotationOffset = (Quaternion)m_currentFrame.Rotation;
+                m_frames.RemoveAt(0);
+                if (m_frames.Count > 0)
+                    m_currentFrame = m_frames[0];
 
-                        update = true;
-                    }
-                    else
-                    {
-                        float complete = ((float)m_currentFrame.TimeTotal - (float)m_currentFrame.TimeMS) / (float)m_currentFrame.TimeTotal;
+                update = true;
+            }
+            else
+            {
+                float complete = ((float)m_currentFrame.TimeTotal - (float)m_currentFrame.TimeMS) / (float)m_currentFrame.TimeTotal;
 
-                        Vector3 v = (Vector3)m_currentFrame.Position - m_group.AbsolutePosition;
-                        Vector3 motionThisFrame = v / (float)steps;
-                        v = v * 1000 / m_currentFrame.TimeMS;
+                Vector3 v = (Vector3)m_currentFrame.Position - m_group.AbsolutePosition;
+                Vector3 motionThisFrame = v / (float)steps;
+                v = v * 1000 / m_currentFrame.TimeMS;
 
-                        if (Vector3.Mag(motionThisFrame) >= 0.05f)
-                        {
-                            //                        m_group.AbsolutePosition += motionThisFrame;
-                            m_nextPosition = m_group.AbsolutePosition + motionThisFrame;
-                            m_group.AbsolutePosition = m_nextPosition;
+                if (Vector3.Mag(motionThisFrame) >= 0.05f)
+                {
+                    // m_group.AbsolutePosition += motionThisFrame;
+                    m_nextPosition = m_group.AbsolutePosition + motionThisFrame;
+                    m_group.AbsolutePosition = m_nextPosition;
 
-                            m_group.RootPart.Velocity = v;
-                            update = true;
-                        }
+                    m_group.RootPart.Velocity = v;
+                    update = true;
+                }
 
-                        if ((Quaternion)m_currentFrame.Rotation != m_group.GroupRotation)
-                        {
-                            Quaternion current = m_group.GroupRotation;
+                if ((Quaternion)m_currentFrame.Rotation != m_group.GroupRotation)
+                {
+                    Quaternion current = m_group.GroupRotation;
 
-                            Quaternion step = Quaternion.Slerp(m_currentFrame.StartRotation, (Quaternion)m_currentFrame.Rotation, complete);
-                            step.Normalize();
+                    Quaternion step = Quaternion.Slerp(m_currentFrame.StartRotation, (Quaternion)m_currentFrame.Rotation, complete);
+                    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)
-                                // assuming w is a dependente var
+* float angle = 0;
 
-                            {
-//                                m_group.UpdateGroupRotationR(step);
-                                m_group.RootPart.RotationOffset = step;
+                    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;
 
-                                //m_group.RootPart.UpdateAngularVelocity(m_currentFrame.AngularVelocity / 2);
-                                update = true;
-                            }
+                    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 (update)
-                        m_group.SendGroupRootTerseUpdate();
-//                        m_group.RootPart.ScheduleTerseUpdate();
+                    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;
 
+                        //m_group.RootPart.UpdateAngularVelocity(m_currentFrame.AngularVelocity / 2);
+                        update = true;
+                    }
                 }
-                catch ( Exception ex)
-                {
-                    // still happening sometimes
-                    // lets try to see where
-                    m_log.Warn("[KeyFrame]: timer overrun" + ex.Message);
-                }
+            }
 
-                finally
-                {
-                    // make sure we do not let this frozen
-                    m_inOnTimer = false;
-                }
+            if (update)
+            {
+                m_group.SendGroupRootTerseUpdate();
             }
         }
 
@@ -677,7 +735,7 @@ namespace OpenSim.Region.Framework.Scenes
             m_isCrossing = true;
             m_waitingCrossing = true;
 
-// to remove / retune to smoth crossings
+            // to remove / retune to smoth crossings
             if (m_group.RootPart.Velocity != Vector3.Zero)
             {
                 m_group.RootPart.Velocity = Vector3.Zero;
@@ -696,9 +754,10 @@ namespace OpenSim.Region.Framework.Scenes
                 m_group.SendGroupRootTerseUpdate();
 //                m_group.RootPart.ScheduleTerseUpdate();
 
-                if (m_running && m_timer != null)
+                if (m_running)
                 {
-                    m_timer.Interval = 60000;
+                    StopTimer();
+                    m_skipLoops = 1200; // 60 seconds
                     StartTimer();
                 }
             }
diff --git a/OpenSim/Region/Framework/Scenes/Scene.Inventory.cs b/OpenSim/Region/Framework/Scenes/Scene.Inventory.cs
index c9d1205..4130029 100644
--- a/OpenSim/Region/Framework/Scenes/Scene.Inventory.cs
+++ b/OpenSim/Region/Framework/Scenes/Scene.Inventory.cs
@@ -401,17 +401,17 @@ namespace OpenSim.Region.Framework.Scenes
                 if (item.Owner != remoteClient.AgentId)
                     return;
 
-                if (UUID.Zero == transactionID)
-                {
-                    item.Flags = (item.Flags & ~(uint)255) | (itemUpd.Flags & (uint)255);
-                    item.Name = itemUpd.Name;
-                    item.Description = itemUpd.Description;
+                item.Flags = (item.Flags & ~(uint)255) | (itemUpd.Flags & (uint)255);
+                item.Name = itemUpd.Name;
+                item.Description = itemUpd.Description;
 
 //                    m_log.DebugFormat(
 //                        "[USER INVENTORY]: itemUpd {0} {1} {2} {3}, item {4} {5} {6} {7}",
 //                        itemUpd.NextPermissions, itemUpd.GroupPermissions, itemUpd.EveryOnePermissions, item.Flags,
 //                        item.NextPermissions, item.GroupPermissions, item.EveryOnePermissions, item.CurrentPermissions);
 
+                if (itemUpd.NextPermissions != 0) // Use this to determine validity. Can never be 0 if valid
+                {
                     if (item.NextPermissions != (itemUpd.NextPermissions & item.BasePermissions))
                         item.Flags |= (uint)InventoryItemFlags.ObjectOverwriteNextOwner;
                     item.NextPermissions = itemUpd.NextPermissions & item.BasePermissions;
@@ -446,7 +446,8 @@ namespace OpenSim.Region.Framework.Scenes
 
                     InventoryService.UpdateItem(item);
                 }
-                else
+
+                if (UUID.Zero != transactionID)
                 {
                     if (AgentTransactionsModule != null)
                     {
diff --git a/OpenSim/Region/Framework/Scenes/Scene.cs b/OpenSim/Region/Framework/Scenes/Scene.cs
index e3bc8c7..2e64819 100644
--- a/OpenSim/Region/Framework/Scenes/Scene.cs
+++ b/OpenSim/Region/Framework/Scenes/Scene.cs
@@ -2769,8 +2769,6 @@ namespace OpenSim.Region.Framework.Scenes
 
             if (newPosition != Vector3.Zero)
                 newObject.RootPart.GroupPosition = newPosition;
-            if (newObject.RootPart.KeyframeMotion != null)
-                newObject.RootPart.KeyframeMotion.UpdateSceneObject(newObject);
 
             if (!AddSceneObject(newObject))
             {
@@ -2798,6 +2796,9 @@ namespace OpenSim.Region.Framework.Scenes
                 // before we restart the scripts, or else some functions won't work.
                 newObject.RootPart.ParentGroup.CreateScriptInstances(0, false, DefaultScriptEngine, GetStateSource(newObject));
                 newObject.ResumeScripts();
+
+                if (newObject.RootPart.KeyframeMotion != null)
+                    newObject.RootPart.KeyframeMotion.UpdateSceneObject(newObject);
             }
 
             // Do this as late as possible so that listeners have full access to the incoming object
@@ -2865,7 +2866,7 @@ namespace OpenSim.Region.Framework.Scenes
                     RootPrim.RemFlag(PrimFlags.TemporaryOnRez);
                     
                     if (AttachmentsModule != null)
-                        AttachmentsModule.AttachObject(sp, grp, 0, false, false, false);
+                        AttachmentsModule.AttachObject(sp, grp, 0, false, false, false, true);
                 }
                 else
                 {
@@ -2970,6 +2971,13 @@ namespace OpenSim.Region.Framework.Scenes
                     SubscribeToClientEvents(client);
     
                     sp = m_sceneGraph.CreateAndAddChildScenePresence(client, aCircuit.Appearance, type);
+                    InventoryFolderBase cof = InventoryService.GetFolderForType(client.AgentId, (AssetType)46);
+                    if (cof == null)
+                        sp.COF = UUID.Zero;
+                    else
+                        sp.COF = cof.ID;
+
+                    m_log.DebugFormat("[SCENE]: COF for {0} is {1}", client.AgentId, sp.COF);
                     m_eventManager.TriggerOnNewPresence(sp);
     
                     sp.TeleportFlags = (TPFlags)aCircuit.teleportFlags;
@@ -3615,7 +3623,7 @@ namespace OpenSim.Region.Framework.Scenes
                     // TODO: We shouldn't use closeChildAgents here - it's being used by the NPC module to stop
                     // unnecessary operations.  This should go away once NPCs have no accompanying IClientAPI
                     if (closeChildAgents && CapsModule != null)
-                        CapsModule.RemoveCaps(agentID);
+                        CapsModule.RemoveCaps(agentID, avatar.ControllingClient.CircuitCode);
     
 //                    // REFACTORING PROBLEM -- well not really a problem, but just to point out that whatever
 //                    // this method is doing is HORRIBLE!!!
@@ -3846,20 +3854,36 @@ namespace OpenSim.Region.Framework.Scenes
                 return false;
             }           
 
-
             ScenePresence sp = GetScenePresence(agent.AgentID);
 
-            if (sp != null && !sp.IsChildAgent)
+            // If we have noo presence here or if that presence is a zombie root
+            // presence that will be kicled, we need a new CAPS object.
+            if (sp == null || (sp != null && !sp.IsChildAgent))
             {
-                // We have a zombie from a crashed session. 
-                // Or the same user is trying to be root twice here, won't work.
-                // Kill it.
-                m_log.WarnFormat(
-                    "[SCENE]: Existing root scene presence detected for {0} {1} in {2} when connecting.  Removing existing presence.",
-                    sp.Name, sp.UUID, RegionInfo.RegionName);
+                if (CapsModule != null)
+                {
+                    lock (agent)
+                    {
+                        CapsModule.SetAgentCapsSeeds(agent);
+                        CapsModule.CreateCaps(agent.AgentID, agent.circuitcode);
+                    }
+                }
+            }
 
-                sp.ControllingClient.Close(true, true);
-                sp = null;
+            if (sp != null)
+            {
+                if (!sp.IsChildAgent)
+                {
+                    // We have a zombie from a crashed session. 
+                    // Or the same user is trying to be root twice here, won't work.
+                    // Kill it.
+                    m_log.WarnFormat(
+                        "[SCENE]: Existing root scene presence detected for {0} {1} in {2} when connecting.  Removing existing presence.",
+                        sp.Name, sp.UUID, RegionInfo.RegionName);
+
+                    sp.ControllingClient.Close(true, true);
+                    sp = null;
+                }
             }
 
             lock (agent)
@@ -3900,7 +3924,9 @@ namespace OpenSim.Region.Framework.Scenes
                         if (vialogin || (!m_seeIntoBannedRegion))
                         {
                             if (!AuthorizeUser(agent, out reason))
+                            {
                                 return false;
+                            }
                         }
                     }
                     catch (Exception e)
@@ -3915,11 +3941,6 @@ namespace OpenSim.Region.Framework.Scenes
                         RegionInfo.RegionName, (agent.child ? "child" : "root"), agent.firstname, agent.lastname,
                         agent.AgentID, agent.circuitcode);
 
-                    if (CapsModule != null)
-                    {
-                        CapsModule.SetAgentCapsSeeds(agent);
-                        CapsModule.CreateCaps(agent.AgentID);
-                    }
                 }
                 else
                 {
@@ -3945,6 +3966,11 @@ namespace OpenSim.Region.Framework.Scenes
             agent.teleportFlags = teleportFlags;
             m_authenticateHandler.AddNewCircuit(agent.circuitcode, agent);
 
+            if (CapsModule != null)
+            {
+                CapsModule.ActivateCaps(agent.circuitcode);
+            }
+
             if (vialogin)
             {
 //                CleanDroppedAttachments();
@@ -5122,7 +5148,7 @@ namespace OpenSim.Region.Framework.Scenes
                     {
                         if ((grp.RootPart.Flags & PrimFlags.TemporaryOnRez) != 0)
                         {
-                            if (grp.RootPart.Expires <= DateTime.Now)
+                            if (grp.GetSittingAvatarsCount() == 0 && grp.RootPart.Expires <= DateTime.Now)
                                 DeleteSceneObject(grp, false);
                         }
                     }
diff --git a/OpenSim/Region/Framework/Scenes/SceneObjectPart.cs b/OpenSim/Region/Framework/Scenes/SceneObjectPart.cs
index 8528edc..20a6626 100644
--- a/OpenSim/Region/Framework/Scenes/SceneObjectPart.cs
+++ b/OpenSim/Region/Framework/Scenes/SceneObjectPart.cs
@@ -1689,6 +1689,10 @@ namespace OpenSim.Region.Framework.Scenes
 
                 if (ParentGroup != null)
                     ParentGroup.HasGroupChanged = true;
+
+                PhysicsActor pa = PhysActor;
+                if (pa != null)
+                    pa.Density = Density;
             }
         }
 
@@ -1708,6 +1712,9 @@ namespace OpenSim.Region.Framework.Scenes
                 if (ParentGroup != null)
                     ParentGroup.HasGroupChanged = true;
 
+                PhysicsActor pa = PhysActor;
+                if (pa != null)
+                    pa.GravModifier = GravityModifier;
             }
         }
 
@@ -1726,10 +1733,14 @@ namespace OpenSim.Region.Framework.Scenes
 
                 if (ParentGroup != null)
                     ParentGroup.HasGroupChanged = true;
+
+                PhysicsActor pa = PhysActor;
+                if (pa != null)
+                    pa.Friction = Friction;
             }
         }
 
-        public float Bounciness
+        public float Restitution
         {
             get { return m_bounce; }
             set
@@ -1744,6 +1755,10 @@ namespace OpenSim.Region.Framework.Scenes
 
                 if (ParentGroup != null)
                     ParentGroup.HasGroupChanged = true;
+
+                PhysicsActor pa = PhysActor;
+                if (pa != null)
+                    pa.Restitution = Restitution;
             }
         }
 
@@ -4493,8 +4508,8 @@ namespace OpenSim.Region.Framework.Scenes
                 GravityModifier = physdata.GravitationModifier;
             if(Friction != physdata.Friction)
                 Friction = physdata.Friction;
-            if(Bounciness != physdata.Bounce)
-                Bounciness = physdata.Bounce;
+            if(Restitution != physdata.Bounce)
+                Restitution = physdata.Bounce;
         }
         /// <summary>
         /// Update the flags on this prim.  This covers properties such as phantom, physics and temporary.
@@ -4657,6 +4672,11 @@ namespace OpenSim.Region.Framework.Scenes
                 pa.SOPName = this.Name; // save object into the PhysActor so ODE internals know the joint/body info
                 pa.SetMaterial(Material);
 
+                pa.Density = Density;
+                pa.GravModifier = GravityModifier;
+                pa.Friction = Friction;
+                pa.Restitution = Restitution;
+
                 if (VolumeDetectActive) // change if not the default only
                     pa.SetVolumeDetect(1);
 
diff --git a/OpenSim/Region/Framework/Scenes/ScenePresence.cs b/OpenSim/Region/Framework/Scenes/ScenePresence.cs
index a9195f7..230cb23 100644
--- a/OpenSim/Region/Framework/Scenes/ScenePresence.cs
+++ b/OpenSim/Region/Framework/Scenes/ScenePresence.cs
@@ -204,6 +204,11 @@ namespace OpenSim.Region.Framework.Scenes
 
         private const int LAND_VELOCITYMAG_MAX = 12;
 
+        private const float FLY_ROLL_MAX_RADIANS = 1.1f;
+
+        private const float FLY_ROLL_RADIANS_PER_UPDATE = 0.06f;
+        private const float FLY_ROLL_RESET_RADIANS_PER_UPDATE = 0.02f;
+
         private float m_health = 100f;
 
         protected ulong crossingFromRegion;
@@ -438,6 +443,8 @@ namespace OpenSim.Region.Framework.Scenes
             get { return (IClientCore)ControllingClient; }
         }
 
+        public UUID COF { get; set; }
+
 //        public Vector3 ParentPosition { get; set; }
 
         /// <summary>
@@ -606,6 +613,14 @@ namespace OpenSim.Region.Framework.Scenes
             }
         }
 
+        // Used for limited viewer 'fake' user rotations.
+        private Vector3 m_AngularVelocity = Vector3.Zero;
+
+        public Vector3 AngularVelocity
+        {
+            get { return m_AngularVelocity; }
+        }
+
         public bool IsChildAgent { get; set; }
         public bool IsLoggingIn { get; set; }
 
@@ -736,6 +751,8 @@ namespace OpenSim.Region.Framework.Scenes
 
         #endregion
 
+
+
         #region Constructor(s)
 
         public ScenePresence(
@@ -1225,6 +1242,85 @@ namespace OpenSim.Region.Framework.Scenes
             ControllingClient.StopFlying(this);
         }
 
+        /// <summary>
+        /// Applies a roll accumulator to the avatar's angular velocity for the avatar fly roll effect.
+        /// </summary>
+        /// <param name="amount">Postive or negative roll amount in radians</param>
+        private void ApplyFlyingRoll(float amount, bool PressingUp, bool PressingDown)
+        {
+            
+            float rollAmount = Util.Clamp(m_AngularVelocity.Z + amount, -FLY_ROLL_MAX_RADIANS, FLY_ROLL_MAX_RADIANS);
+            m_AngularVelocity.Z = rollAmount;
+
+            // APPLY EXTRA consideration for flying up and flying down during this time.
+            // if we're turning left
+            if (amount > 0)
+            {
+
+                // If we're at the max roll and pressing up, we want to swing BACK a bit
+                // Automatically adds noise
+                if (PressingUp)
+                {
+                    if (m_AngularVelocity.Z >= FLY_ROLL_MAX_RADIANS - 0.04f)
+                        m_AngularVelocity.Z -= 0.9f;
+                }
+                // If we're at the max roll and pressing down, we want to swing MORE a bit
+                if (PressingDown)
+                {
+                    if (m_AngularVelocity.Z >= FLY_ROLL_MAX_RADIANS && m_AngularVelocity.Z < FLY_ROLL_MAX_RADIANS + 0.6f)
+                        m_AngularVelocity.Z += 0.6f;
+                }
+            }
+            else  // we're turning right.
+            {
+                // If we're at the max roll and pressing up, we want to swing BACK a bit
+                // Automatically adds noise
+                if (PressingUp)
+                {
+                    if (m_AngularVelocity.Z <= (-FLY_ROLL_MAX_RADIANS))
+                        m_AngularVelocity.Z += 0.6f;
+                }
+                // If we're at the max roll and pressing down, we want to swing MORE a bit
+                if (PressingDown)
+                {
+                    if (m_AngularVelocity.Z >= -FLY_ROLL_MAX_RADIANS - 0.6f)
+                        m_AngularVelocity.Z -= 0.6f;
+                }
+            }
+        }
+
+        /// <summary>
+        /// incrementally sets roll amount to zero
+        /// </summary>
+        /// <param name="amount">Positive roll amount in radians</param>
+        /// <returns></returns>
+        private float CalculateFlyingRollResetToZero(float amount)
+        {
+            const float rollMinRadians = 0f;
+
+            if (m_AngularVelocity.Z > 0)
+            {
+                
+                float leftOverToMin = m_AngularVelocity.Z - rollMinRadians;
+                if (amount > leftOverToMin)
+                    return -leftOverToMin;
+                else
+                    return -amount;
+
+            }
+            else
+            {
+                
+                float leftOverToMin = -m_AngularVelocity.Z - rollMinRadians;
+                if (amount > leftOverToMin)
+                    return leftOverToMin;
+                else
+                    return amount;
+            }
+        }
+        
+
+
         // neighbouring regions we have enabled a child agent in
         // holds the seed cap for the child agent in that region
         private Dictionary<ulong, string> m_knownChildRegions = new Dictionary<ulong, string>();
@@ -1430,17 +1526,42 @@ namespace OpenSim.Region.Framework.Scenes
             m_doingCamRayCast = false;
             if (hitYN && localid != LocalId)
             {
-                CameraConstraintActive = true;
-                pNormal.X = (float)Math.Round(pNormal.X, 2);
-                pNormal.Y = (float)Math.Round(pNormal.Y, 2);
-                pNormal.Z = (float)Math.Round(pNormal.Z, 2);
-                pNormal.Normalize();
-                collisionPoint.X = (float)Math.Round(collisionPoint.X, 1);
-                collisionPoint.Y = (float)Math.Round(collisionPoint.Y, 1);
-                collisionPoint.Z = (float)Math.Round(collisionPoint.Z, 1);
-
-                Vector4 plane = new Vector4(pNormal.X, pNormal.Y, pNormal.Z, Vector3.Dot(collisionPoint, pNormal));
-                UpdateCameraCollisionPlane(plane);
+                SceneObjectGroup group = m_scene.GetGroupByPrim(localid);
+                bool IsPrim = group != null;
+                if (IsPrim)
+                {
+                    SceneObjectPart part = group.GetPart(localid);
+                    if (part != null && !part.VolumeDetectActive)
+                    {
+                        CameraConstraintActive = true;
+                        pNormal.X = (float) Math.Round(pNormal.X, 2);
+                        pNormal.Y = (float) Math.Round(pNormal.Y, 2);
+                        pNormal.Z = (float) Math.Round(pNormal.Z, 2);
+                        pNormal.Normalize();
+                        collisionPoint.X = (float) Math.Round(collisionPoint.X, 1);
+                        collisionPoint.Y = (float) Math.Round(collisionPoint.Y, 1);
+                        collisionPoint.Z = (float) Math.Round(collisionPoint.Z, 1);
+
+                        Vector4 plane = new Vector4(pNormal.X, pNormal.Y, pNormal.Z,
+                                                    Vector3.Dot(collisionPoint, pNormal));
+                        UpdateCameraCollisionPlane(plane);
+                    }
+                }
+                else
+                {
+                    CameraConstraintActive = true;
+                    pNormal.X = (float) Math.Round(pNormal.X, 2);
+                    pNormal.Y = (float) Math.Round(pNormal.Y, 2);
+                    pNormal.Z = (float) Math.Round(pNormal.Z, 2);
+                    pNormal.Normalize();
+                    collisionPoint.X = (float) Math.Round(collisionPoint.X, 1);
+                    collisionPoint.Y = (float) Math.Round(collisionPoint.Y, 1);
+                    collisionPoint.Z = (float) Math.Round(collisionPoint.Z, 1);
+
+                    Vector4 plane = new Vector4(pNormal.X, pNormal.Y, pNormal.Z,
+                                                Vector3.Dot(collisionPoint, pNormal));
+                    UpdateCameraCollisionPlane(plane);
+                }
             }
             else if (!m_pos.ApproxEquals(m_lastPosition, POSITION_TOLERANCE) ||
                      !Rotation.ApproxEquals(m_lastRotation, ROTATION_TOLERANCE))
@@ -1741,6 +1862,33 @@ namespace OpenSim.Region.Framework.Scenes
                     bool controlland = (((flags & AgentManager.ControlFlags.AGENT_CONTROL_UP_NEG) != 0) ||
                                         ((flags & AgentManager.ControlFlags.AGENT_CONTROL_NUDGE_UP_NEG) != 0));
 
+
+                   //m_log.Debug("[CONTROL]: " +flags);
+                    // Applies a satisfying roll effect to the avatar when flying.
+                    if (((flags & AgentManager.ControlFlags.AGENT_CONTROL_TURN_LEFT) != 0) && ((flags & AgentManager.ControlFlags.AGENT_CONTROL_YAW_POS) != 0))
+                    {
+
+                        ApplyFlyingRoll(FLY_ROLL_RADIANS_PER_UPDATE, ((flags & AgentManager.ControlFlags.AGENT_CONTROL_UP_POS) != 0), ((flags & AgentManager.ControlFlags.AGENT_CONTROL_UP_NEG) != 0));
+                        
+                        
+                    } 
+                    else if (((flags & AgentManager.ControlFlags.AGENT_CONTROL_TURN_RIGHT) != 0) &&
+                             ((flags & AgentManager.ControlFlags.AGENT_CONTROL_YAW_NEG) != 0))
+                    {
+                        ApplyFlyingRoll(-FLY_ROLL_RADIANS_PER_UPDATE, ((flags & AgentManager.ControlFlags.AGENT_CONTROL_UP_POS) != 0), ((flags & AgentManager.ControlFlags.AGENT_CONTROL_UP_NEG) != 0));
+                       
+
+                    }
+                    else
+                    {
+                        if (m_AngularVelocity.Z != 0)
+                            m_AngularVelocity.Z += CalculateFlyingRollResetToZero(FLY_ROLL_RESET_RADIANS_PER_UPDATE);
+                        
+                    }
+
+                   
+
+
                     if (Flying && IsColliding && controlland)
                     {
                         // nesting this check because LengthSquared() is expensive and we don't 
diff --git a/OpenSim/Region/Framework/Scenes/Serialization/SceneObjectSerializer.cs b/OpenSim/Region/Framework/Scenes/Serialization/SceneObjectSerializer.cs
index 123c158..2984782 100644
--- a/OpenSim/Region/Framework/Scenes/Serialization/SceneObjectSerializer.cs
+++ b/OpenSim/Region/Framework/Scenes/Serialization/SceneObjectSerializer.cs
@@ -633,7 +633,7 @@ namespace OpenSim.Region.Framework.Scenes.Serialization
 
         private static void ProcessBounce(SceneObjectPart obj, XmlTextReader reader)
         {
-            obj.Bounciness = reader.ReadElementContentAsFloat("Bounce", String.Empty);
+            obj.Restitution = reader.ReadElementContentAsFloat("Bounce", String.Empty);
         }
 
         private static void ProcessGravityModifier(SceneObjectPart obj, XmlTextReader reader)
@@ -1363,8 +1363,8 @@ namespace OpenSim.Region.Framework.Scenes.Serialization
                 writer.WriteElementString("Density", sop.Density.ToString().ToLower());
             if (sop.Friction != 0.6f)
                 writer.WriteElementString("Friction", sop.Friction.ToString().ToLower());
-            if (sop.Bounciness != 0.5f)
-                writer.WriteElementString("Bounce", sop.Bounciness.ToString().ToLower());
+            if (sop.Restitution != 0.5f)
+                writer.WriteElementString("Bounce", sop.Restitution.ToString().ToLower());
             if (sop.GravityModifier != 1.0f)
                 writer.WriteElementString("GravityModifier", sop.GravityModifier.ToString().ToLower());
             WriteVector(writer, "CameraEyeOffset", sop.GetCameraEyeOffset());