Merge branch 'master' into vehicles

10 files changed, 738 insertions, 45 deletions

diff --git a/OpenSim/Framework/Communications/RestClient.cs b/OpenSim/Framework/Communications/RestClient.cs
index a74169e..97b3b60 100644
--- a/OpenSim/Framework/Communications/RestClient.cs
+++ b/OpenSim/Framework/Communications/RestClient.cs
@@ -403,7 +403,7 @@ namespace OpenSim.Framework.Communications
             /// In case, we are invoked asynchroneously this object will keep track of the state
             /// </summary>
             AsyncResult<Stream> ar = new AsyncResult<Stream>(callback, state);
-            ThreadPool.QueueUserWorkItem(RequestHelper, ar);
+            Util.FireAndForget(RequestHelper, ar);
             return ar;
         }
 
diff --git a/OpenSim/Framework/IClientAPI.cs b/OpenSim/Framework/IClientAPI.cs
index 9fd043c..d304345 100644
--- a/OpenSim/Framework/IClientAPI.cs
+++ b/OpenSim/Framework/IClientAPI.cs
@@ -448,6 +448,10 @@ namespace OpenSim.Framework
     public delegate void AvatarInterestUpdate(IClientAPI client, uint wantmask, string wanttext, uint skillsmask, string skillstext, string languages);
     public delegate void PlacesQuery(UUID QueryID, UUID TransactionID, string QueryText, uint QueryFlags, byte Category, string SimName, IClientAPI client);
 
+    public delegate void AgentFOV(IClientAPI client, float verticalAngle);
+
+    public delegate double UpdatePriorityHandler(UpdatePriorityData data);
+
     #endregion
 
     public struct DirPlacesReplyData
@@ -517,6 +521,232 @@ namespace OpenSim.Framework
         public float dwell;
     }
 
+    public struct SendAvatarData
+    {
+        public readonly ulong RegionHandle;
+        public readonly string FirstName;
+        public readonly string LastName;
+        public readonly string GroupTitle;
+        public readonly UUID AvatarID;
+        public readonly uint AvatarLocalID;
+        public readonly Vector3 Position;
+        public readonly byte[] TextureEntry;
+        public readonly uint ParentID;
+        public readonly Quaternion Rotation;
+
+        public SendAvatarData(ulong regionHandle, string firstName, string lastName, string groupTitle, UUID avatarID,
+            uint avatarLocalID, Vector3 position, byte[] textureEntry, uint parentID, Quaternion rotation)
+        {
+            RegionHandle = regionHandle;
+            FirstName = firstName;
+            LastName = lastName;
+            GroupTitle = groupTitle;
+            AvatarID = avatarID;
+            AvatarLocalID = avatarLocalID;
+            Position = position;
+            TextureEntry = textureEntry;
+            ParentID = parentID;
+            Rotation = rotation;
+        }
+    }
+
+    public struct SendAvatarTerseData
+    {
+        public readonly ulong RegionHandle;
+        public readonly ushort TimeDilation;
+        public readonly uint LocalID;
+        public readonly Vector3 Position;
+        public readonly Vector3 Velocity;
+        public readonly Vector3 Acceleration;
+        public readonly Quaternion Rotation;
+        public readonly Vector4 CollisionPlane;
+        public readonly UUID AgentID;
+        public readonly byte[] TextureEntry;
+        public readonly double Priority;
+
+        public SendAvatarTerseData(ulong regionHandle, ushort timeDilation, uint localID, Vector3 position, Vector3 velocity,
+            Vector3 acceleration, Quaternion rotation, Vector4 collisionPlane, UUID agentid, byte[] textureEntry, double priority)
+        {
+            RegionHandle = regionHandle;
+            TimeDilation = timeDilation;
+            LocalID = localID;
+            Position = position;
+            Velocity = velocity;
+            Acceleration = acceleration;
+            Rotation = rotation;
+            CollisionPlane = collisionPlane;
+            AgentID = agentid;
+            TextureEntry = textureEntry;
+            Priority = priority;
+        }
+    }
+
+    public struct SendPrimitiveTerseData
+    {
+        public readonly ulong RegionHandle;
+        public readonly ushort TimeDilation;
+        public readonly uint LocalID;
+        public readonly Vector3 Position;
+        public readonly Quaternion Rotation;
+        public readonly Vector3 Velocity;
+        public readonly Vector3 Acceleration;
+        public readonly Vector3 AngularVelocity;
+        public readonly byte State;
+        public readonly UUID AssetID;
+        public readonly UUID OwnerID;
+        public readonly int AttachPoint;
+        public readonly byte[] TextureEntry;
+        public readonly double Priority;
+
+        public SendPrimitiveTerseData(ulong regionHandle, ushort timeDilation, uint localID, Vector3 position,
+            Quaternion rotation, Vector3 velocity, Vector3 acceleration, Vector3 rotationalvelocity, byte state,
+            UUID assetID, UUID ownerID, int attachPoint, byte[] textureEntry, double priority)
+        {
+            RegionHandle = regionHandle;
+            TimeDilation = timeDilation;
+            LocalID = localID;
+            Position = position;
+            Rotation = rotation;
+            Velocity = velocity;
+            Acceleration = acceleration;
+            AngularVelocity = rotationalvelocity;
+            State = state;
+            AssetID = assetID;
+            OwnerID = ownerID;
+            AttachPoint = attachPoint;
+            TextureEntry = textureEntry;
+            Priority = priority;
+        }
+    }
+
+    public struct SendPrimitiveData
+    {
+        private ulong m_regionHandle;
+        private ushort m_timeDilation;
+        private uint m_localID;
+        private PrimitiveBaseShape m_primShape;
+        private Vector3 m_pos;
+        private Vector3 m_vel;
+        private Vector3 m_acc;
+        private Quaternion m_rotation;
+        private Vector3 m_rvel;
+        private PrimFlags m_flags;
+        private UUID m_objectID;
+        private UUID m_ownerID;
+        private string m_text;
+        private byte[] m_color;
+        private uint m_parentID;
+        private byte[] m_particleSystem;
+        private byte m_clickAction;
+        private byte m_material;
+        private byte[] m_textureanim;
+        private bool m_attachment;
+        private uint m_AttachPoint;
+        private UUID m_AssetId;
+        private UUID m_SoundId;
+        private double m_SoundVolume;
+        private byte m_SoundFlags;
+        private double m_SoundRadius;
+        private double m_priority;
+
+        public SendPrimitiveData(ulong regionHandle, ushort timeDilation, uint localID, PrimitiveBaseShape primShape,
+                                   Vector3 pos, Vector3 vel, Vector3 acc, Quaternion rotation, Vector3 rvel,
+                                   uint flags, UUID objectID, UUID ownerID, string text, byte[] color,
+                                   uint parentID, byte[] particleSystem, byte clickAction, byte material, double priority) :
+            this(regionHandle, timeDilation, localID, primShape, pos, vel, acc, rotation, rvel, flags, objectID,
+            ownerID, text, color, parentID, particleSystem, clickAction, material, new byte[0], false, 0, UUID.Zero,
+            UUID.Zero, 0, 0, 0, priority) { }
+
+        public SendPrimitiveData(ulong regionHandle, ushort timeDilation, uint localID, PrimitiveBaseShape primShape,
+                                   Vector3 pos, Vector3 vel, Vector3 acc, Quaternion rotation, Vector3 rvel,
+                                   uint flags,
+                                   UUID objectID, UUID ownerID, string text, byte[] color, uint parentID,
+                                   byte[] particleSystem,
+                                   byte clickAction, byte material, byte[] textureanim, bool attachment,
+                                   uint AttachPoint, UUID AssetId, UUID SoundId, double SoundVolume, byte SoundFlags,
+                                   double SoundRadius, double priority)
+        {
+            this.m_regionHandle = regionHandle;
+            this.m_timeDilation = timeDilation;
+            this.m_localID = localID;
+            this.m_primShape = primShape;
+            this.m_pos = pos;
+            this.m_vel = vel;
+            this.m_acc = acc;
+            this.m_rotation = rotation;
+            this.m_rvel = rvel;
+            this.m_flags = (PrimFlags)flags;
+            this.m_objectID = objectID;
+            this.m_ownerID = ownerID;
+            this.m_text = text;
+            this.m_color = color;
+            this.m_parentID = parentID;
+            this.m_particleSystem = particleSystem;
+            this.m_clickAction = clickAction;
+            this.m_material = material;
+            this.m_textureanim = textureanim;
+            this.m_attachment = attachment;
+            this.m_AttachPoint = AttachPoint;
+            this.m_AssetId = AssetId;
+            this.m_SoundId = SoundId;
+            this.m_SoundVolume = SoundVolume;
+            this.m_SoundFlags = SoundFlags;
+            this.m_SoundRadius = SoundRadius;
+            this.m_priority = priority;
+        }
+
+        public ulong regionHandle { get { return this.m_regionHandle; } }
+        public ushort timeDilation { get { return this.m_timeDilation; } }
+        public uint localID { get { return this.m_localID; } }
+        public PrimitiveBaseShape primShape { get { return this.m_primShape; } }
+        public Vector3 pos { get { return this.m_pos; } }
+        public Vector3 vel { get { return this.m_vel; } }
+        public Vector3 acc { get { return this.m_acc; } }
+        public Quaternion rotation { get { return this.m_rotation; } }
+        public Vector3 rvel { get { return this.m_rvel; } }
+        public PrimFlags flags { get { return this.m_flags; } }
+        public UUID objectID { get { return this.m_objectID; } }
+        public UUID ownerID { get { return this.m_ownerID; } }
+        public string text { get { return this.m_text; } }
+        public byte[] color { get { return this.m_color; } }
+        public uint parentID { get { return this.m_parentID; } }
+        public byte[] particleSystem { get { return this.m_particleSystem; } }
+        public byte clickAction { get { return this.m_clickAction; } }
+        public byte material { get { return this.m_material; } }
+        public byte[] textureanim { get { return this.m_textureanim; } }
+        public bool attachment { get { return this.m_attachment; } }
+        public uint AttachPoint { get { return this.m_AttachPoint; } }
+        public UUID AssetId { get { return this.m_AssetId; } }
+        public UUID SoundId { get { return this.m_SoundId; } }
+        public double SoundVolume { get { return this.m_SoundVolume; } }
+        public byte SoundFlags { get { return this.m_SoundFlags; } }
+        public double SoundRadius { get { return this.m_SoundRadius; } }
+        public double priority { get { return this.m_priority; } }
+    }
+
+    public struct UpdatePriorityData {
+        private double m_priority;
+        private uint m_localID;
+
+        public UpdatePriorityData(double priority, uint localID) {
+            this.m_priority = priority;
+            this.m_localID = localID;
+        }
+
+        public double priority { get { return this.m_priority; } }
+        public uint localID { get { return this.m_localID; } }
+    }
+
+    [Flags]
+    public enum StateUpdateTypes
+    {
+        None = 0,
+        AvatarTerse = 1,
+        PrimitiveTerse = AvatarTerse << 1,
+        PrimitiveFull = PrimitiveTerse << 1,
+        All = AvatarTerse | PrimitiveTerse | PrimitiveFull,
+    }
+
     public interface IClientAPI
     {
         Vector3 StartPos { get; set; }
@@ -878,37 +1108,20 @@ namespace OpenSim.Framework
         void SendMoneyBalance(UUID transaction, bool success, byte[] description, int balance);
         void SendPayPrice(UUID objectID, int[] payPrice);
 
-        void SendAvatarData(ulong regionHandle, string firstName, string lastName, string grouptitle, UUID avatarID,
-                            uint avatarLocalID,
-                            Vector3 Pos, byte[] textureEntry, uint parentID, Quaternion rotation);
+        void SendAvatarData(SendAvatarData data);
 
-        void SendAvatarTerseUpdate(ulong regionHandle, ushort timeDilation, uint localID, Vector3 position,
-                                   Vector3 velocity, Quaternion rotation, UUID agentid);
+        void SendAvatarTerseUpdate(SendAvatarTerseData data);
 
         void SendCoarseLocationUpdate(List<UUID> users, List<Vector3> CoarseLocations);
 
         void AttachObject(uint localID, Quaternion rotation, byte attachPoint, UUID ownerID);
         void SetChildAgentThrottle(byte[] throttle);
 
-        void SendPrimitiveToClient(ulong regionHandle, ushort timeDilation, uint localID, PrimitiveBaseShape primShape,
-                                   Vector3 pos, Vector3 vel, Vector3 acc, Quaternion rotation, Vector3 rvel,
-                                   uint flags,
-                                   UUID objectID, UUID ownerID, string text, byte[] color, uint parentID,
-                                   byte[] particleSystem,
-                                   byte clickAction, byte material, byte[] textureanim, bool attachment,
-                                   uint AttachPoint, UUID AssetId, UUID SoundId, double SoundVolume, byte SoundFlags,
-                                   double SoundRadius);
-
-
-        void SendPrimitiveToClient(ulong regionHandle, ushort timeDilation, uint localID, PrimitiveBaseShape primShape,
-                                   Vector3 pos, Vector3 vel, Vector3 acc, Quaternion rotation, Vector3 rvel,
-                                   uint flags, UUID objectID, UUID ownerID, string text, byte[] color,
-                                   uint parentID, byte[] particleSystem, byte clickAction, byte material);
+        void SendPrimitiveToClient(SendPrimitiveData data);
 
+        void SendPrimTerseUpdate(SendPrimitiveTerseData data);
 
-        void SendPrimTerseUpdate(ulong regionHandle, ushort timeDilation, uint localID, Vector3 position,
-                                 Quaternion rotation, Vector3 velocity, Vector3 rotationalvelocity, byte state,
-                                 UUID AssetId, UUID owner, int attachPoint);
+        void ReprioritizeUpdates(StateUpdateTypes type, UpdatePriorityHandler handler);
 
         void SendInventoryFolderDetails(UUID ownerID, UUID folderID, List<InventoryItemBase> items,
                                         List<InventoryFolderBase> folders, bool fetchFolders,
diff --git a/OpenSim/Framework/Location.cs b/OpenSim/Framework/Location.cs
index 62ab5c7..9504e03 100644
--- a/OpenSim/Framework/Location.cs
+++ b/OpenSim/Framework/Location.cs
@@ -98,7 +98,7 @@ namespace OpenSim.Framework
 
         public override int GetHashCode()
         {
-            return X.GetHashCode() * 29 + Y.GetHashCode();
+            return X.GetHashCode() ^ Y.GetHashCode();
         }
 
         public object Clone()
diff --git a/OpenSim/Framework/MainServer.cs b/OpenSim/Framework/MainServer.cs
index b5f947e..7da4893 100644
--- a/OpenSim/Framework/MainServer.cs
+++ b/OpenSim/Framework/MainServer.cs
@@ -26,17 +26,36 @@
  */
 
 using OpenSim.Framework.Servers.HttpServer;
+using System.Collections.Generic;
 
 namespace OpenSim.Framework
 {
     public class MainServer
     {
         private static BaseHttpServer instance;
+        private static Dictionary<uint, BaseHttpServer> m_Servers =
+                new Dictionary<uint, BaseHttpServer>();
 
         public static BaseHttpServer Instance
         {
             get { return instance; }
             set { instance = value; }
         }
+
+        public static IHttpServer GetHttpServer(uint port)
+        {
+            if (port == 0)
+                return Instance;
+            if (port == Instance.Port)
+                return Instance;
+
+            if (m_Servers.ContainsKey(port))
+                return m_Servers[port];
+
+            m_Servers[port] = new BaseHttpServer(port);
+            m_Servers[port].Start();
+
+            return m_Servers[port];
+        }
     }
 }
diff --git a/OpenSim/Framework/MinHeap.cs b/OpenSim/Framework/MinHeap.cs
new file mode 100755
index 0000000..ad39bbc
--- /dev/null
+++ b/OpenSim/Framework/MinHeap.cs
@@ -0,0 +1,375 @@
+using System;
+using System.Threading;
+using System.Collections;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+
+namespace OpenSim.Framework
+{
+    public interface IHandle { }
+
+    [Serializable, ComVisible(false)]
+    public class MinHeap<T> : ICollection<T>, ICollection
+    {
+        private class Handle : IHandle
+        {
+            internal int index = -1;
+            internal MinHeap<T> heap = null;
+
+            internal void Clear()
+            {
+                this.index = -1;
+                this.heap = null;
+            }
+        }
+
+        private struct HeapItem
+        {
+            internal T value;
+            internal Handle handle;
+
+            internal HeapItem(T value, Handle handle)
+            {
+                this.value = value;
+                this.handle = handle;
+            }
+
+            internal void Clear()
+            {
+                this.value = default(T);
+                if (this.handle != null)
+                {
+                    this.handle.Clear();
+                    this.handle = null;
+                }
+            }
+        }
+
+        public const int DEFAULT_CAPACITY = 4;
+
+        private HeapItem[] items;
+        private int size;
+        private object sync_root;
+        private int version;
+
+        private Comparison<T> comparison;
+
+        public MinHeap() : this(DEFAULT_CAPACITY, Comparer<T>.Default) { }
+        public MinHeap(int capacity) : this(capacity, Comparer<T>.Default) { }
+        public MinHeap(IComparer<T> comparer) : this(DEFAULT_CAPACITY, comparer) { }
+        public MinHeap(int capacity, IComparer<T> comparer) :
+            this(capacity, new Comparison<T>(comparer.Compare)) { }
+        public MinHeap(Comparison<T> comparison) : this(DEFAULT_CAPACITY, comparison) { }
+        public MinHeap(int capacity, Comparison<T> comparison)
+        {
+            this.items = new HeapItem[capacity];
+            this.comparison = comparison;
+            this.size = this.version = 0;
+        }
+
+        public int Count { get { return this.size; } }
+
+        public bool IsReadOnly { get { return false; } }
+
+        public bool IsSynchronized { get { return false; } }
+
+        public T this[IHandle key]
+        {
+            get
+            {
+                Handle handle = ValidateThisHandle(key);
+                return this.items[handle.index].value;
+            }
+
+            set
+            {
+                Handle handle = ValidateThisHandle(key);
+                this.items[handle.index].value = value;
+                if (!BubbleUp(handle.index))
+                    BubbleDown(handle.index);
+            }
+        }
+
+        public object SyncRoot
+        {
+            get
+            {
+                if (this.sync_root == null)
+                    Interlocked.CompareExchange<object>(ref this.sync_root, new object(), null);
+                return this.sync_root;
+            }
+        }
+
+        private Handle ValidateHandle(IHandle ihandle)
+        {
+            if (ihandle == null)
+                throw new ArgumentNullException("handle");
+            Handle handle = ihandle as Handle;
+            if (handle == null)
+                throw new InvalidOperationException("handle is not valid");
+            return handle;
+        }
+
+        private Handle ValidateThisHandle(IHandle ihandle)
+        {
+            Handle handle = ValidateHandle(ihandle);
+            if (!object.ReferenceEquals(handle.heap, this))
+                throw new InvalidOperationException("handle is not valid for this heap");
+            if (handle.index < 0)
+                throw new InvalidOperationException("handle is not associated to a value");
+            return handle;
+        }
+
+        private void Set(HeapItem item, int index)
+        {
+            this.items[index] = item;
+            if (item.handle != null)
+                item.handle.index = index;
+        }
+
+        private bool BubbleUp(int index)
+        {
+            HeapItem item = this.items[index];
+            int current, parent;
+
+            for (current = index, parent = (current - 1) / 2;
+                (current > 0) && (this.comparison(this.items[parent].value, item.value)) > 0;
+                current = parent, parent = (current - 1) / 2)
+            {
+                Set(this.items[parent], current);
+            }
+
+            if (current != index)
+            {
+                Set(item, current);
+                ++this.version;
+                return true;
+            }
+            return false;
+        }
+
+        private void BubbleDown(int index)
+        {
+            HeapItem item = this.items[index];
+            int current, child;
+
+            for (current = index, child = (2 * current) + 1;
+                current < this.size / 2;
+                current = child, child = (2 * current) + 1)
+            {
+                if ((child < this.size - 1) && this.comparison(this.items[child].value, this.items[child + 1].value) > 0)
+                    ++child;
+                if (this.comparison(this.items[child].value, item.value) >= 0)
+                    break;
+                Set(this.items[child], current);
+            }
+
+            if (current != index)
+            {
+                Set(item, current);
+                ++this.version;
+            }
+        }
+
+        public bool TryGetValue(IHandle key, out T value)
+        {
+            Handle handle = ValidateHandle(key);
+            if (handle.index > -1)
+            {
+                value = this.items[handle.index].value;
+                return true;
+            }
+            value = default(T);
+            return false;
+        }
+
+        public bool ContainsHandle(IHandle ihandle)
+        {
+            Handle handle = ValidateHandle(ihandle);
+            return object.ReferenceEquals(handle.heap, this) && handle.index > -1;
+        }
+
+        public void Add(T value, ref IHandle handle)
+        {
+            if (handle == null)
+                handle = new Handle();
+            Add(value, handle);
+        }
+
+        public void Add(T value, IHandle ihandle)
+        {
+            if (this.size == this.items.Length)
+            {
+                int capacity = (int)((this.items.Length * 200L) / 100L);
+                if (capacity < (this.items.Length + DEFAULT_CAPACITY))
+                    capacity = this.items.Length + DEFAULT_CAPACITY;
+                Array.Resize<HeapItem>(ref this.items, capacity);
+            }
+
+            Handle handle = null;
+            if (ihandle != null)
+            {
+                handle = ValidateHandle(ihandle);
+                handle.heap = this;
+            }
+
+            HeapItem item = new MinHeap<T>.HeapItem(value, handle);
+
+            Set(item, this.size);
+            BubbleUp(this.size++);
+        }
+
+        public void Add(T value)
+        {
+            Add(value, null);
+        }
+
+        public T Min()
+        {
+            if (this.size == 0)
+                throw new InvalidOperationException("Heap is empty");
+
+            return this.items[0].value;
+        }
+
+        public void Clear()
+        {
+            for (int index = 0; index < this.size; ++index)
+                this.items[index].Clear();
+            this.size = 0;
+            ++this.version;
+        }
+
+        public void TrimExcess()
+        {
+            int length = (int)(this.items.Length * 0.9);
+            if (this.size < length)
+                Array.Resize<HeapItem>(ref this.items, Math.Min(this.size, DEFAULT_CAPACITY));
+        }
+
+        private void RemoveAt(int index)
+        {
+            if (this.size == 0)
+                throw new InvalidOperationException("Heap is empty");
+            if (index >= this.size)
+                throw new ArgumentOutOfRangeException("index");
+
+            this.items[index].Clear();
+            if (--this.size > 0 && index != this.size)
+            {
+                Set(this.items[this.size], index);
+                if (!BubbleUp(index))
+                    BubbleDown(index);
+            }
+        }
+
+        public T RemoveMin()
+        {
+            if (this.size == 0)
+                throw new InvalidOperationException("Heap is empty");
+
+            HeapItem item = this.items[0];
+            RemoveAt(0);
+            return item.value;
+        }
+
+        public T Remove(IHandle ihandle)
+        {
+            Handle handle = ValidateThisHandle(ihandle);
+            HeapItem item = this.items[handle.index];
+            RemoveAt(handle.index);
+            return item.value;
+        }
+
+        private int GetIndex(T value)
+        {
+            EqualityComparer<T> comparer = EqualityComparer<T>.Default;
+            int index;
+
+            for (index = 0; index < this.size; ++index)
+            {
+                if (comparer.Equals(this.items[index].value, value))
+                    return index;
+            }
+            return -1;
+        }
+
+        public bool Contains(T value)
+        {
+            return GetIndex(value) != -1;
+        }
+
+        public bool Remove(T value)
+        {
+            int index = GetIndex(value);
+            if (index != -1)
+            {
+                RemoveAt(index);
+                return true;
+            }
+            return false;
+        }
+
+        public void CopyTo(T[] array, int index)
+        {
+            if (array == null)
+                throw new ArgumentNullException("array");
+            if (array.Rank != 1)
+                throw new ArgumentException("Multidimensional array not supported");
+            if (array.GetLowerBound(0) != 0)
+                throw new ArgumentException("Non-zero lower bound array not supported");
+
+            int length = array.Length;
+            if ((index < 0) || (index > length))
+                throw new ArgumentOutOfRangeException("index");
+            if ((length - index) < this.size)
+                throw new ArgumentException("Not enough space available in array starting at index");
+
+            for (int i = 0; i < this.size; ++i)
+                array[index + i] = this.items[i].value;
+        }
+
+        public void CopyTo(Array array, int index)
+        {
+            if (array == null)
+                throw new ArgumentNullException("array");
+            if (array.Rank != 1)
+                throw new ArgumentException("Multidimensional array not supported");
+            if (array.GetLowerBound(0) != 0)
+                throw new ArgumentException("Non-zero lower bound array not supported");
+
+            int length = array.Length;
+            if ((index < 0) || (index > length))
+                throw new ArgumentOutOfRangeException("index");
+            if ((length - index) < this.size)
+                throw new ArgumentException("Not enough space available in array starting at index");
+
+            try
+            {
+                for (int i = 0; i < this.size; ++i)
+                    array.SetValue(this.items[i].value, index + i);
+            }
+            catch (ArrayTypeMismatchException)
+            {
+                throw new ArgumentException("Invalid array type");
+            }
+        }
+
+        public IEnumerator<T> GetEnumerator()
+        {
+            int version = this.version;
+
+            for (int index = 0; index < this.size; ++index)
+            {
+                if (version != this.version)
+                    throw new InvalidOperationException("Heap was modified while enumerating");
+                yield return this.items[index].value;
+            }
+        }
+
+        IEnumerator IEnumerable.GetEnumerator()
+        {
+            return GetEnumerator();
+        }
+    }
+}
diff --git a/OpenSim/Framework/Parallel.cs b/OpenSim/Framework/Parallel.cs
index 6efdad0..70eecdc 100644
--- a/OpenSim/Framework/Parallel.cs
+++ b/OpenSim/Framework/Parallel.cs
@@ -36,7 +36,7 @@ namespace OpenSim.Framework
     /// </summary>
     public static class Parallel
     {
-        private static readonly int processorCount = System.Environment.ProcessorCount;
+        public static readonly int ProcessorCount = System.Environment.ProcessorCount;
 
         /// <summary>
         /// Executes a for loop in which iterations may run in parallel
@@ -46,7 +46,7 @@ namespace OpenSim.Framework
         /// <param name="body">Method body to run for each iteration of the loop</param>
         public static void For(int fromInclusive, int toExclusive, Action<int> body)
         {
-            For(processorCount, fromInclusive, toExclusive, body);
+            For(ProcessorCount, fromInclusive, toExclusive, body);
         }
 
         /// <summary>
@@ -66,7 +66,7 @@ namespace OpenSim.Framework
 
             for (int i = 0; i < threadCount; i++)
             {
-                ThreadPool.QueueUserWorkItem(
+                Util.FireAndForget(
                     delegate(object o)
                     {
                         int threadIndex = (int)o;
@@ -103,7 +103,7 @@ namespace OpenSim.Framework
         /// <param name="body">Method body to run for each object in the collection</param>
         public static void ForEach<T>(IEnumerable<T> enumerable, Action<T> body)
         {
-            ForEach<T>(processorCount, enumerable, body);
+            ForEach<T>(ProcessorCount, enumerable, body);
         }
 
         /// <summary>
@@ -122,7 +122,7 @@ namespace OpenSim.Framework
 
             for (int i = 0; i < threadCount; i++)
             {
-                ThreadPool.QueueUserWorkItem(
+                Util.FireAndForget(
                     delegate(object o)
                     {
                         int threadIndex = (int)o;
@@ -161,7 +161,7 @@ namespace OpenSim.Framework
         /// <param name="actions">A series of method bodies to execute</param>
         public static void Invoke(params Action[] actions)
         {
-            Invoke(processorCount, actions);
+            Invoke(ProcessorCount, actions);
         }
 
         /// <summary>
@@ -178,7 +178,7 @@ namespace OpenSim.Framework
 
             for (int i = 0; i < threadCount; i++)
             {
-                ThreadPool.QueueUserWorkItem(
+                Util.FireAndForget(
                     delegate(object o)
                     {
                         int threadIndex = (int)o;
diff --git a/OpenSim/Framework/RegionInfo.cs b/OpenSim/Framework/RegionInfo.cs
index a7315f5..721233d 100644
--- a/OpenSim/Framework/RegionInfo.cs
+++ b/OpenSim/Framework/RegionInfo.cs
@@ -821,7 +821,7 @@ namespace OpenSim.Framework
                                                 "Scope ID for this region", ScopeID.ToString(), true);
 
             configMember.addConfigurationOption("region_type", ConfigurationOption.ConfigurationTypes.TYPE_STRING,
-                                                "Region Type", String.Empty, true);
+                                                "Free form string describing the type of region", String.Empty, true);
         }
 
         public void loadConfigurationOptions()
@@ -978,11 +978,12 @@ namespace OpenSim.Framework
 
         public void SaveLastMapUUID(UUID mapUUID)
         {
-            if (null == configMember) return;
-
             lastMapUUID = mapUUID;
             lastMapRefresh = Util.UnixTimeSinceEpoch().ToString();
 
+            if (configMember == null)
+                return;
+
             configMember.forceSetConfigurationOption("lastmap_uuid", mapUUID.ToString());
             configMember.forceSetConfigurationOption("lastmap_refresh", lastMapRefresh);
         }
diff --git a/OpenSim/Framework/Servers/HttpServer/BaseHttpServer.cs b/OpenSim/Framework/Servers/HttpServer/BaseHttpServer.cs
index 942fed9..85d7be2 100644
--- a/OpenSim/Framework/Servers/HttpServer/BaseHttpServer.cs
+++ b/OpenSim/Framework/Servers/HttpServer/BaseHttpServer.cs
@@ -1609,7 +1609,7 @@ namespace OpenSim.Framework.Servers.HttpServer
                 //while (true)
                 //{
                 //    context = m_httpListener.GetContext();
-                //    ThreadPool.QueueUserWorkItem(new WaitCallback(HandleRequest), context);
+                //    ThreadPool.UnsafeQueueUserWorkItem(new WaitCallback(HandleRequest), context);
                // }
             }
             catch (Exception e)
diff --git a/OpenSim/Framework/ThrottleOutPacketType.cs b/OpenSim/Framework/ThrottleOutPacketType.cs
index e21ff32..d56231a 100644
--- a/OpenSim/Framework/ThrottleOutPacketType.cs
+++ b/OpenSim/Framework/ThrottleOutPacketType.cs
@@ -51,4 +51,16 @@ namespace OpenSim.Framework
         /// <remarks>This is a sub-category of Task</remarks>
         State = 7,
     }
+
+    [Flags]
+    public enum ThrottleOutPacketTypeFlags
+    {
+        Land = 1 << 0,
+        Wind = 1 << 1,
+        Cloud = 1 << 2,
+        Task = 1 << 3,
+        Texture = 1 << 4,
+        Asset = 1 << 5,
+        State = 1 << 6,
+    }
 }
diff --git a/OpenSim/Framework/Util.cs b/OpenSim/Framework/Util.cs
index 38729c6..d09bd6d 100644
--- a/OpenSim/Framework/Util.cs
+++ b/OpenSim/Framework/Util.cs
@@ -41,19 +41,36 @@ using System.Security.Cryptography;
 using System.Text;
 using System.Text.RegularExpressions;
 using System.Xml;
+using System.Threading;
 using log4net;
 using Nini.Config;
 using Nwc.XmlRpc;
+using BclExtras;
 using OpenMetaverse;
 using OpenMetaverse.StructuredData;
+using Amib.Threading;
 
 namespace OpenSim.Framework
 {
     /// <summary>
+    /// The method used by Util.FireAndForget for asynchronously firing events
+    /// </summary>
+    public enum FireAndForgetMethod
+    {
+        UnsafeQueueUserWorkItem,
+        QueueUserWorkItem,
+        BeginInvoke,
+        SmartThreadPool,
+        Thread,
+    }
+
+    /// <summary>
     /// Miscellaneous utility functions
     /// </summary>
     public class Util
     {
+        private static SmartThreadPool m_ThreadPool = null;
+
         private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
 
         private static uint nextXferID = 5000;
@@ -69,7 +86,9 @@ namespace OpenSim.Framework
 
         public static readonly Regex UUIDPattern 
             = new Regex("^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$");
-        
+
+        public static FireAndForgetMethod FireAndForgetMethod = FireAndForgetMethod.SmartThreadPool;
+
         /// <summary>
         /// Linear interpolates B<->C using percent A
         /// </summary>
@@ -1269,24 +1288,78 @@ namespace OpenSim.Framework
 
         #region FireAndForget Threading Pattern
 
-        public static void FireAndForget(System.Threading.WaitCallback callback)
+        /// <summary>
+        /// Created to work around a limitation in Mono with nested delegates
+        /// </summary>
+        private class FireAndForgetWrapper
         {
-            callback.BeginInvoke(null, EndFireAndForget, callback);
+            public void FireAndForget(System.Threading.WaitCallback callback)
+            {
+                callback.BeginInvoke(null, EndFireAndForget, callback);
+            }
+
+            public void FireAndForget(System.Threading.WaitCallback callback, object obj)
+            {
+                callback.BeginInvoke(obj, EndFireAndForget, callback);
+            }
+
+            private static void EndFireAndForget(IAsyncResult ar)
+            {
+                System.Threading.WaitCallback callback = (System.Threading.WaitCallback)ar.AsyncState;
+
+                try { callback.EndInvoke(ar); }
+                catch (Exception ex) { m_log.Error("[UTIL]: Asynchronous method threw an exception: " + ex.Message, ex); }
+
+                ar.AsyncWaitHandle.Close();
+            }
         }
 
-        public static void FireAndForget(System.Threading.WaitCallback callback, object obj)
+        public static void FireAndForget(System.Threading.WaitCallback callback)
         {
-            callback.BeginInvoke(obj, EndFireAndForget, callback);
+            FireAndForget(callback, null);
         }
 
-        private static void EndFireAndForget(IAsyncResult ar)
+        public static void SetMaxThreads(int maxThreads)
         {
-            System.Threading.WaitCallback callback = (System.Threading.WaitCallback)ar.AsyncState;
+            if (m_ThreadPool != null)
+                return;
+
+            STPStartInfo startInfo = new STPStartInfo();
+            startInfo.IdleTimeout = 2000; // 2 seconds
+            startInfo.MaxWorkerThreads = maxThreads;
+            startInfo.MinWorkerThreads = 2;
+            startInfo.StackSize = 524288;
+            startInfo.ThreadPriority = ThreadPriority.Normal;
 
-            try { callback.EndInvoke(ar); }
-            catch (Exception ex) { m_log.Error("[UTIL]: Asynchronous method threw an exception: " + ex.Message, ex); }
+            startInfo.StartSuspended = false;
+
+            m_ThreadPool = new SmartThreadPool(startInfo);
+        }
 
-            ar.AsyncWaitHandle.Close();
+        public static void FireAndForget(System.Threading.WaitCallback callback, object obj)
+        {
+            switch (FireAndForgetMethod)
+            {
+                case FireAndForgetMethod.UnsafeQueueUserWorkItem:
+                    System.Threading.ThreadPool.UnsafeQueueUserWorkItem(callback, obj);
+                    break;
+                case FireAndForgetMethod.QueueUserWorkItem:
+                    System.Threading.ThreadPool.QueueUserWorkItem(callback, obj);
+                    break;
+                case FireAndForgetMethod.BeginInvoke:
+                    FireAndForgetWrapper wrapper = Singleton.GetInstance<FireAndForgetWrapper>();
+                    wrapper.FireAndForget(callback, obj);
+                    break;
+                case FireAndForgetMethod.SmartThreadPool:
+                    m_ThreadPool.QueueWorkItem(delegate(object o) { callback(o); return null; }, obj);
+                    break;
+                case FireAndForgetMethod.Thread:
+                    System.Threading.Thread thread = new System.Threading.Thread(delegate(object o) { callback(o); });
+                    thread.Start(obj);
+                    break;
+                default:
+                    throw new NotImplementedException();
+            }
         }
 
         #endregion FireAndForget Threading Pattern