/// <summary>
 /// Add the part to the queue of parts for which we need to send an update to the client
 /// </summary>
 /// <param name="part"></param>
 public void QueuePartForUpdate(SceneObjectPart part, PrimUpdateFlags UpdateFlags)
 {
     lock (m_partsUpdateQueue)
     {
         PrimUpdate update = new PrimUpdate();
         update.Part = part;
         update.UpdateFlags = UpdateFlags;
         m_partsUpdateQueue.Enqueue(update);
     }
 }

        /// <summary>
        /// Add the part to the queue of parts for which we need to send an update to the client
        /// </summary>
        /// <param name="part"></param>
        public void QueuePartForUpdate(SceneObjectPart part, PrimUpdateFlags UpdateFlags)
        {
            lock (m_partsUpdateQueue)
            {
                PrimUpdate update = new PrimUpdate();
                update.Part = part;
                update.UpdateFlags = UpdateFlags;
                m_partsUpdateQueue.Enqueue(update);

                //Make it check when the user comes around to it again
                if (m_objectsInView.Contains(part.UUID))
                    m_objectsInView.Remove(part.UUID);
            }
        }

        public void SendAttachmentScheduleUpdate(SceneObjectGroup sog)
        {
            if (IsChildAgent || IsInTransit)
                return;

            SceneObjectPart[] origparts = sog.Parts;
            SceneObjectPart[] parts = new SceneObjectPart[origparts.Length];
            PrimUpdateFlags[] flags = new PrimUpdateFlags[origparts.Length];

            SceneObjectPart rootpart = sog.RootPart;
            UpdateRequired rootreq = sog.RootPart.UpdateFlag;

            int j = 0;
            bool allterse = true;
            for (int i = 0; i < origparts.Length; i++)
            {
                if (origparts[i] != rootpart)
                {
                    switch (origparts[i].UpdateFlag)
                    {
                        case UpdateRequired.NONE:
                            break;

                        case UpdateRequired.TERSE:
                            flags[j] = PrimUpdateFlags.Position | PrimUpdateFlags.Rotation | PrimUpdateFlags.Velocity
                            | PrimUpdateFlags.Acceleration | PrimUpdateFlags.AngularVelocity;
                            parts[j] = origparts[i];
                            j++;
                            break;

                        case UpdateRequired.FULL:
                            flags[j] = PrimUpdateFlags.FullUpdate;
                            allterse = false;
                            parts[j] = origparts[i];
                            j++;
                            break;
                    }
                }
                origparts[i].UpdateFlag = 0;
            }

            if (j == 0 && rootreq == UpdateRequired.NONE)
                return;

            PrimUpdateFlags rootflag = PrimUpdateFlags.FullUpdate;

            if (rootreq != UpdateRequired.FULL && allterse)
            {
                rootflag = PrimUpdateFlags.Position | PrimUpdateFlags.Rotation | PrimUpdateFlags.Velocity
                        | PrimUpdateFlags.Acceleration | PrimUpdateFlags.AngularVelocity;
            }

            int nparts = j;

            ControllingClient.SendEntityUpdate(rootpart, rootflag);

            for (int i = 0; i < nparts; i++)
            {
                ControllingClient.SendEntityUpdate(parts[i], flags[i]);
            }

            if (sog.HasPrivateAttachmentPoint)
                return;

            List<ScenePresence> allPresences = m_scene.GetScenePresences();
            foreach (ScenePresence p in allPresences)
            {
                if (p == this)
                    continue;

                if (ParcelHideThisAvatar && currentParcelUUID != p.currentParcelUUID && p.GodLevel < 200)
                    continue;

                p.ControllingClient.SendEntityUpdate(rootpart, rootflag);

                for (int i = 0; i < nparts; i++)
                {
                    p.ControllingClient.SendEntityUpdate(parts[i], flags[i]);
                }
            }
        }

 /// <summary>
 /// Tell a specific avatar about the update
 /// </summary>
 /// <param name="UpdateFlags"></param>
 /// <param name="avatar"></param>
 public void ScheduleUpdateToAvatar(PrimUpdateFlags UpdateFlags, ScenePresence avatar)
 {
     PrimUpdateFlags PostUpdateFlags;
     if (ShouldScheduleUpdate(UpdateFlags, out PostUpdateFlags))
     {
         avatar.AddUpdateToAvatar(this, PostUpdateFlags);
     }
 }

 /// <summary>
 /// Check to see whether the given flags make it a terse update
 /// </summary>
 /// <param name="flags"></param>
 /// <returns></returns>
 private bool IsTerse(PrimUpdateFlags flags)
 {
     return flags.HasFlag((PrimUpdateFlags.Position | PrimUpdateFlags.Rotation
         | PrimUpdateFlags.Velocity | PrimUpdateFlags.Acceleration | PrimUpdateFlags.AngularVelocity))
         && !flags.HasFlag((PrimUpdateFlags.AttachmentPoint | PrimUpdateFlags.ClickAction |
         PrimUpdateFlags.CollisionPlane | PrimUpdateFlags.ExtraData | PrimUpdateFlags.FindBest | PrimUpdateFlags.FullUpdate |
         PrimUpdateFlags.Joint | PrimUpdateFlags.Material | PrimUpdateFlags.MediaURL | PrimUpdateFlags.NameValue |
         PrimUpdateFlags.ParentID | PrimUpdateFlags.Particles | PrimUpdateFlags.PrimData | PrimUpdateFlags.PrimFlags |
         PrimUpdateFlags.ScratchPad | PrimUpdateFlags.Shape | PrimUpdateFlags.Sound | PrimUpdateFlags.Text |
         PrimUpdateFlags.TextureAnim | PrimUpdateFlags.Textures));
 }

 public void SendPrimUpdate(ISceneEntity entity, PrimUpdateFlags updateFlags)
 {
 }

        /// <summary>
        ///   Send an update to all prims in the group to a specific avatar
        /// </summary>
        /// <param name = "presence"></param>
        /// <param name = "UpdateFlags"></param>
        public void ScheduleGroupUpdateToAvatar(IScenePresence presence, PrimUpdateFlags UpdateFlags)
        {
            //We have to send the root part first as the client wants it that way
            presence.AddUpdateToAvatar(RootPart, UpdateFlags);

#if (!ISWIN)
            foreach (SceneObjectPart part in m_partsList)
            {
                if (part != RootPart)
                {
                    presence.AddUpdateToAvatar(part, UpdateFlags);
                }
            }
#else
            foreach (SceneObjectPart part in m_partsList.Where(part => part != RootPart))
            {
                presence.AddUpdateToAvatar(part, UpdateFlags);
            }
#endif
        }

 public EntityUpdate(ISceneEntity entity, PrimUpdateFlags flags, float timedilation, Int32 updateTime)
     : base(entity,(uint)flags,updateTime)
 {
     m_timeDilation = timedilation;
 }

 public void SendPrimitiveToClient(object sop, uint clientFlags, OpenMetaverse.Vector3 lpos, PrimUpdateFlags updateFlags)
 {
 }

        /// <summary>
        ///   Tell all avatars in the Scene about the new update
        /// </summary>
        /// <param name = "UpdateFlags"></param>
        public void ScheduleUpdate(PrimUpdateFlags UpdateFlags)
        {
#if (!ISWIN)
            m_parentGroup.Scene.ForEachScenePresence(delegate(IScenePresence avatar)
            {
                avatar.AddUpdateToAvatar(this, UpdateFlags);
            });
#else
            m_parentGroup.Scene.ForEachScenePresence(avatar => avatar.AddUpdateToAvatar(this, UpdateFlags));
#endif
        }

 /// <summary>
 ///     Tell all avatars in the Scene about the new update
 /// </summary>
 /// <param name="UpdateFlags"></param>
 public void ScheduleUpdate(PrimUpdateFlags UpdateFlags)
 {
     if (m_parentGroup != null && m_parentGroup.Scene != null)
         m_parentGroup.Scene.ForEachScenePresence(avatar => avatar.AddUpdateToAvatar(this, UpdateFlags));
 }

 public EntityUpdate (IEntity entity, PrimUpdateFlags flags)
 {
     Entity = entity;
     Flags = flags;
 }

 /// <summary>
 ///     Check to see whether the given flags make it a terse update
 /// </summary>
 /// <param name="flags"></param>
 /// <returns></returns>
 bool IsTerse(PrimUpdateFlags flags)
 {
     return flags.HasFlag((PrimUpdateFlags.TerseUpdate))
            && !flags.HasFlag((PrimUpdateFlags.AttachmentPoint | PrimUpdateFlags.ClickAction |
                               PrimUpdateFlags.CollisionPlane | PrimUpdateFlags.ExtraData |
                               PrimUpdateFlags.FindBest | PrimUpdateFlags.FullUpdate |
                               PrimUpdateFlags.Joint | PrimUpdateFlags.Material | PrimUpdateFlags.MediaURL |
                               PrimUpdateFlags.NameValue |
                               PrimUpdateFlags.ParentID | PrimUpdateFlags.Particles | PrimUpdateFlags.PrimData |
                               PrimUpdateFlags.PrimFlags |
                               PrimUpdateFlags.ScratchPad | PrimUpdateFlags.Shape | PrimUpdateFlags.Sound |
                               PrimUpdateFlags.Text |
                               PrimUpdateFlags.TextureAnim | PrimUpdateFlags.Textures)) &&
            !flags.HasFlag(PrimUpdateFlags.ForcedFullUpdate);
 }

        /// <summary>
        /// Send an update to all prims in the group to a specific avatar
        /// </summary>
        /// <param name="presence"></param>
        /// <param name="UpdateFlags"></param>
        public void ScheduleGroupUpdateToAvatar (IScenePresence presence, PrimUpdateFlags UpdateFlags)
        {
            //We have to send the root part first as the client wants it that way
            RootPart.ScheduleUpdateToAvatar(UpdateFlags, presence);

            lock (m_partsLock)
            {
                foreach (SceneObjectPart part in m_partsList)
                {
                    if (part != RootPart)
                    {
                        part.ScheduleUpdateToAvatar(UpdateFlags, presence);
                    }
                }
            }
        }

 public void SendPrimUpdate(ISceneEntity entity, PrimUpdateFlags updateFlags, double priority)
 {
 }

        /// <summary>
        /// Tell all the prims which have had updates scheduled
        /// </summary>
        public void SendScheduledUpdates(UpdateLevel level, PrimUpdateFlags updateFlags)
        {
            switch (level)
            {
                case UpdateLevel.Terse:
                    AddTerseUpdateToAllAvatars();
                    break;

                /*case UpdateLevel.Compressed:
                    AddCompressedUpdateToAllAvatars();
                    break;*/

                case UpdateLevel.Full:
                    AddFullUpdateToAllAvatars(updateFlags);
                    break;
            }
        }

 /// <summary>
 /// Tell the SceneViewer for the given client about the update
 /// </summary>
 /// <param name="part"></param>
 /// <param name="flags"></param>
 public void AddUpdateToAvatar(ISceneChildEntity part, PrimUpdateFlags flags)
 {
    lock (m_terseUpdates)
         m_terseUpdates.Add(new OUpdates {Child = part, Flags = flags});
     Scene.SceneGraph.TaintPresenceForUpdate(this, PresenceTaint.ObjectUpdates);
 }

 public static bool HasFlag(this PrimUpdateFlags updateFlags, PrimUpdateFlags flag)
 {
     return (updateFlags & flag) == flag;
 }

 /// <summary>
 /// Tell all scene presences that they should send updates for this part to their clients
 /// </summary>
 public void AddFullUpdateToAllAvatars(PrimUpdateFlags flags)
 {
     List<ScenePresence> avatars = m_parentGroup.Scene.GetScenePresences();
     foreach (ScenePresence avatar in avatars)
     {
         if (!(avatar.IsDeleted || avatar.IsInTransit))
             avatar.SceneView.QueuePartForUpdate(this, flags);
     }
 }

        /// <summary>
        ///   Send an update to all prims in the group
        /// </summary>
        /// <param name = "UpdateFlags"></param>
        public void ScheduleGroupUpdate(PrimUpdateFlags UpdateFlags)
        {
            //We have to send the root part first as the client wants it that way
            RootPart.ScheduleUpdate(UpdateFlags);

#if (!ISWIN)
            foreach (SceneObjectPart part in m_partsList)
            {
                if (part != RootPart)
                {
                    part.ScheduleUpdate(UpdateFlags);
                }
            }
#else
            foreach (SceneObjectPart part in m_partsList.Where(part => part != RootPart))
            {
                part.ScheduleUpdate(UpdateFlags);
            }
#endif
        }