Dump OpenSim 0.9.0.1 into it's own branch.

1 files changed, 132 insertions, 32 deletions

diff --git a/OpenSim/Region/Framework/Scenes/Prioritizer.cs b/OpenSim/Region/Framework/Scenes/Prioritizer.cs
index ae85560..53ca849 100644
--- a/OpenSim/Region/Framework/Scenes/Prioritizer.cs
+++ b/OpenSim/Region/Framework/Scenes/Prioritizer.cs
@@ -35,7 +35,7 @@ using OpenSim.Region.PhysicsModules.SharedBase;
 
 /*
  * Steps to add a new prioritization policy:
- * 
+ *
  *  - Add a new value to the UpdatePrioritizationSchemes enum.
  *  - Specify this new value in the [InterestManagement] section of your
  *    OpenSim.ini. The name in the config file must match the enum value name
@@ -59,7 +59,7 @@ namespace OpenSim.Region.Framework.Scenes
     public class Prioritizer
     {
         private static readonly ILog m_log = LogManager.GetLogger(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType);
-        
+
         private Scene m_scene;
 
         public Prioritizer(Scene scene)
@@ -91,9 +91,10 @@ namespace OpenSim.Region.Framework.Scenes
                 return 0;
 
             uint priority;
-            
+
             switch (m_scene.UpdatePrioritizationScheme)
             {
+/*
                 case UpdatePrioritizationSchemes.Time:
                     priority = GetPriorityByTime(client, entity);
                     break;
@@ -106,13 +107,16 @@ namespace OpenSim.Region.Framework.Scenes
                 case UpdatePrioritizationSchemes.FrontBack:
                     priority = GetPriorityByFrontBack(client, entity);
                     break;
+*/
+                case UpdatePrioritizationSchemes.SimpleAngularDistance:
+                    priority = GetPriorityByAngularDistance(client, entity); // TODO: Reimplement SimpleAngularDistance
+                    break;
                 case UpdatePrioritizationSchemes.BestAvatarResponsiveness:
+                default:
                     priority = GetPriorityByBestAvatarResponsiveness(client, entity);
                     break;
-                default:
-                    throw new InvalidOperationException("UpdatePrioritizationScheme not defined.");
             }
-            
+
             return priority;
         }
 
@@ -141,7 +145,7 @@ namespace OpenSim.Region.Framework.Scenes
 
             return ComputeDistancePriority(client,entity,false);
         }
-        
+
         private uint GetPriorityByFrontBack(IClientAPI client, ISceneEntity entity)
         {
             // And anything attached to this avatar gets top priority as well
@@ -157,30 +161,39 @@ namespace OpenSim.Region.Framework.Scenes
 
         private uint GetPriorityByBestAvatarResponsiveness(IClientAPI client, ISceneEntity entity)
         {
-            uint pqueue = ComputeDistancePriority(client,entity,true);
+            uint pqueue = 2; // keep compiler happy
 
             ScenePresence presence = m_scene.GetScenePresence(client.AgentId);
             if (presence != null)
             {
-                if (!presence.IsChildAgent)
+                // All avatars other than our own go into pqueue 1
+                if (entity is ScenePresence)
+                    return 1;
+
+                if (entity is SceneObjectPart)
                 {
-                    // All avatars other than our own go into pqueue 1
-                    if (entity is ScenePresence)
-                        return 1;
+                    SceneObjectGroup sog = ((SceneObjectPart)entity).ParentGroup;
+                    // Attachments are high priority,
+                    if (sog.IsAttachment)
+                        return 2;
                     
-                    if (entity is SceneObjectPart)
+
+                    if(presence.ParentPart != null)
                     {
-                        // Attachments are high priority, 
-                        if (((SceneObjectPart)entity).ParentGroup.IsAttachment)
-                            return 1;
-
-                        // Non physical prims are lower priority than physical prims
-                        PhysicsActor physActor = ((SceneObjectPart)entity).ParentGroup.RootPart.PhysActor;
-                        if (physActor == null || !physActor.IsPhysical)
-                            pqueue++;
+                        if(presence.ParentPart.ParentGroup == sog)
+                            return 2;
                     }
+
+                    pqueue = ComputeDistancePriority(client, entity, false);
+
+                    // Non physical prims are lower priority than physical prims
+                    PhysicsActor physActor = sog.RootPart.PhysActor;
+                    if (physActor == null || !physActor.IsPhysical)
+                        pqueue++;
                 }
             }
+            else
+                pqueue = ComputeDistancePriority(client, entity, false);
 
             return pqueue;
         }
@@ -191,7 +204,7 @@ namespace OpenSim.Region.Framework.Scenes
             ScenePresence presence = m_scene.GetScenePresence(client.AgentId);
             if (presence == null)
             {
-                // this shouldn't happen, it basically means that we are prioritizing 
+                // this shouldn't happen, it basically means that we are prioritizing
                 // updates to send to a client that doesn't have a presence in the scene
                 // seems like there's race condition here...
 
@@ -199,7 +212,7 @@ namespace OpenSim.Region.Framework.Scenes
                 // throw new InvalidOperationException("Prioritization agent not defined");
                 return PriorityQueue.NumberOfQueues - 1;
             }
-                
+
             // Use group position for child prims, since we are putting child prims in
             // the same queue with the root of the group, the root prim (which goes into
             // the queue first) should always be sent first, no need to adjust child prim
@@ -212,25 +225,43 @@ namespace OpenSim.Region.Framework.Scenes
             }
 
             // Use the camera position for local agents and avatar position for remote agents
-            Vector3 presencePos = (presence.IsChildAgent) ?
-                presence.AbsolutePosition :
-                presence.CameraPosition;
+            // Why would I want that? They could be camming but I still see them at the
+            // avatar position, so why should I update them as if they were at their
+            // camera positions? Makes no sense!
+            // TODO: Fix this mess
+            //Vector3 presencePos = (presence.IsChildAgent) ?
+            //    presence.AbsolutePosition :
+            //    presence.CameraPosition;
+
+            Vector3 presencePos = presence.AbsolutePosition;
 
-            // Compute the distance... 
+            // Compute the distance...
             double distance = Vector3.Distance(presencePos, entityPos);
 
             // And convert the distance to a priority queue, this computation gives queues
             // at 10, 20, 40, 80, 160, 320, 640, and 1280m
-            uint pqueue = PriorityQueue.NumberOfImmediateQueues;
+            uint pqueue = PriorityQueue.NumberOfImmediateQueues + 1; // reserve attachments queue
             uint queues = PriorityQueue.NumberOfQueues - PriorityQueue.NumberOfImmediateQueues;
-            
+/*
             for (int i = 0; i < queues - 1; i++)
             {
-                if (distance < 10 * Math.Pow(2.0,i))
+                if (distance < 30 * Math.Pow(2.0,i))
                     break;
                 pqueue++;
             }
-            
+*/
+            if (distance > 10f)
+            {
+                float tmp = (float)Math.Log((double)distance) * 1.442695f - 3.321928f;
+                // for a map identical to original:
+                // now
+                // 1st constant is 1/(log(2)) (natural log) so we get log2(distance)
+                // 2st constant makes it be log2(distance/10)
+                pqueue += (uint)tmp;
+                if (pqueue > queues - 1)
+                    pqueue = queues - 1;
+            }
+
             // If this is a root agent, then determine front & back
             // Bump up the priority queue (drop the priority) for any objects behind the avatar
             if (useFrontBack && ! presence.IsChildAgent)
@@ -242,12 +273,81 @@ namespace OpenSim.Region.Framework.Scenes
                 // Plane equation
                 float d = -Vector3.Dot(camPosition, camAtAxis);
                 float p = Vector3.Dot(camAtAxis, entityPos) + d;
-                if (p < 0.0f) 
+                if (p < 0.0f)
                     pqueue++;
             }
 
             return pqueue;
         }
 
+        private uint GetPriorityByAngularDistance(IClientAPI client, ISceneEntity entity)
+        {
+            ScenePresence presence = m_scene.GetScenePresence(client.AgentId);
+            if (presence == null)
+                return PriorityQueue.NumberOfQueues - 1;
+
+            uint pqueue = ComputeAngleDistancePriority(presence, entity);
+            return pqueue;
+        }
+
+        private uint ComputeAngleDistancePriority(ScenePresence presence, ISceneEntity entity)
+        {
+            // And convert the distance to a priority queue, this computation gives queues
+            // at 10, 20, 40, 80, 160, 320, 640, and 1280m
+//            uint minpqueue = PriorityQueue.NumberOfImmediateQueues;
+            uint maxqueue = PriorityQueue.NumberOfQueues - PriorityQueue.NumberOfImmediateQueues -1;
+//            uint pqueue = minpqueue;
+            uint pqueue = PriorityQueue.NumberOfImmediateQueues;
+            float distance;
+
+            Vector3 presencePos = presence.AbsolutePosition;
+            if(entity is ScenePresence)
+            {
+                ScenePresence sp = entity as ScenePresence;
+                distance = Vector3.Distance(presencePos, sp.AbsolutePosition);
+                distance *= 0.5f;
+            }
+            else
+            {
+                SceneObjectGroup group = (entity as SceneObjectPart).ParentGroup;
+                if(presence.ParentPart != null)
+                {
+                    if(presence.ParentPart.ParentGroup == group)
+                        return pqueue;
+                }
+                if(group.IsAttachment)
+                {
+                    if(group.RootPart.LocalId == presence.LocalId)
+                        return pqueue;
+                }
+
+                float bradius = group.GetBoundsRadius();
+                Vector3 grppos = group.AbsolutePosition + group.getBoundsCenter();
+                distance = Vector3.Distance(presencePos, grppos);
+                distance -= bradius;
+                distance *= group.getAreaFactor();
+                if(group.IsAttachment)
+                    distance *= 0.5f;
+                else if(group.UsesPhysics)
+                    distance *= 0.6f;
+                else if(group.GetSittingAvatarsCount() > 0)
+                    distance *= 0.5f;
+            }
+
+            if (distance > 10f)
+            {
+                float tmp = (float)Math.Log(distance) * 1.442695f - 3.321928f;
+                // for a map identical to original:
+                // now
+                // 1st constant is 1/(log(2)) (natural log) so we get log2(distance)
+                // 2st constant makes it be log2(distance/10)
+
+                pqueue += (uint)tmp;
+                if (pqueue > maxqueue)
+                    pqueue = maxqueue;
+            }
+
+            return pqueue;
+        }
     }
 }