1 files changed, 70 insertions, 36 deletions

diff --git a/OpenSim/Region/ClientStack/Linden/UDP/LLClientView.cs b/OpenSim/Region/ClientStack/Linden/UDP/LLClientView.cs
index b0cb4ea..06f1301 100644
--- a/OpenSim/Region/ClientStack/Linden/UDP/LLClientView.cs
+++ b/OpenSim/Region/ClientStack/Linden/UDP/LLClientView.cs
@@ -3838,47 +3838,53 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                 m_entityUpdates.Enqueue(priority, new EntityUpdate(entity, updateFlags, m_scene.TimeDilation));
         }
 
-        /// <summary>
-        /// Requeue an EntityUpdate when it was not acknowledged by the client. 
-        /// We will update the priority and put it in the correct queue, merging update flags 
-        /// with any other updates that may be queued for the same entity. 
-        /// The original update time is used for the merged update.
-        /// </summary>
-        private void ResendPrimUpdate(EntityUpdate update)
-        {
-            // If the update exists in priority queue, it will be updated.
-            // If it does not exist then it will be added with the current (rather than its original) priority
-            uint priority = m_prioritizer.GetUpdatePriority(this, update.Entity);
+        /*  dont use this
+            udp packet resent must be done at udp level only
+            re map from a packet to original updates just doesnt work                           
 
-            lock (m_entityUpdates.SyncRoot)
-                m_entityUpdates.Enqueue(priority, update);
-        }
+                /// <summary>
+                /// Requeue an EntityUpdate when it was not acknowledged by the client. 
+                /// We will update the priority and put it in the correct queue, merging update flags 
+                /// with any other updates that may be queued for the same entity. 
+                /// The original update time is used for the merged update.
+                /// </summary>
+                private void ResendPrimUpdate(EntityUpdate update)
+                {
+                    // If the update exists in priority queue, it will be updated.
+                    // If it does not exist then it will be added with the current (rather than its original) priority
+                    uint priority = m_prioritizer.GetUpdatePriority(this, update.Entity);
 
-        /// <summary>
-        /// Requeue a list of EntityUpdates when they were not acknowledged by the client. 
-        /// We will update the priority and put it in the correct queue, merging update flags 
-        /// with any other updates that may be queued for the same entity. 
-        /// The original update time is used for the merged update.
-        /// </summary>
-        private void ResendPrimUpdates(List<EntityUpdate> updates, OutgoingPacket oPacket)
-        {
-            // m_log.WarnFormat("[CLIENT] resending prim updates {0}, packet sequence number {1}", updates[0].UpdateTime, oPacket.SequenceNumber);
+                    lock (m_entityUpdates.SyncRoot)
+                        m_entityUpdates.Enqueue(priority, update);
+                }
 
-            // Remove the update packet from the list of packets waiting for acknowledgement
-            // because we are requeuing the list of updates. They will be resent in new packets
-            // with the most recent state and priority.
-            m_udpClient.NeedAcks.Remove(oPacket.SequenceNumber);
 
-            // Count this as a resent packet since we are going to requeue all of the updates contained in it
-            Interlocked.Increment(ref m_udpClient.PacketsResent);           
+                /// <summary>
+                /// Requeue a list of EntityUpdates when they were not acknowledged by the client. 
+                /// We will update the priority and put it in the correct queue, merging update flags 
+                /// with any other updates that may be queued for the same entity. 
+                /// The original update time is used for the merged update.
+                /// </summary>
+                private void ResendPrimUpdates(List<EntityUpdate> updates, OutgoingPacket oPacket)
+                {
+                    // m_log.WarnFormat("[CLIENT] resending prim updates {0}, packet sequence number {1}", updates[0].UpdateTime, oPacket.SequenceNumber);
 
-            // We're not going to worry about interlock yet since its not currently critical that this total count
-            // is 100% correct
-            m_udpServer.PacketsResentCount++;
+                    // Remove the update packet from the list of packets waiting for acknowledgement
+                    // because we are requeuing the list of updates. They will be resent in new packets
+                    // with the most recent state and priority.
+                    m_udpClient.NeedAcks.Remove(oPacket.SequenceNumber);
 
-            foreach (EntityUpdate update in updates)
-                ResendPrimUpdate(update);
-        }
+                    // Count this as a resent packet since we are going to requeue all of the updates contained in it
+                    Interlocked.Increment(ref m_udpClient.PacketsResent);           
+
+                    // We're not going to worry about interlock yet since its not currently critical that this total count
+                    // is 100% correct
+                    m_udpServer.PacketsResentCount++;
+
+                    foreach (EntityUpdate update in updates)
+                        ResendPrimUpdate(update);
+                }
+        */
 
 //        OpenSim.Framework.Lazy<List<ObjectUpdatePacket.ObjectDataBlock>> objectUpdateBlocks = new OpenSim.Framework.Lazy<List<ObjectUpdatePacket.ObjectDataBlock>>();
 //        OpenSim.Framework.Lazy<List<ObjectUpdateCompressedPacket.ObjectDataBlock>> compressedUpdateBlocks = new OpenSim.Framework.Lazy<List<ObjectUpdateCompressedPacket.ObjectDataBlock>>();
@@ -4197,12 +4203,40 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                 for (int i = 0; i < blocks.Count; i++)
                     packet.ObjectData[i] = blocks[i];
     
-                OutPacket(packet, ThrottleOutPacketType.Task, true, delegate(OutgoingPacket oPacket) { ResendPrimUpdates(terseUpdates.Value, oPacket); });
+//                OutPacket(packet, ThrottleOutPacketType.Task, true, delegate(OutgoingPacket oPacket) { ResendPrimUpdates(terseUpdates.Value, oPacket); });
+                // use default udp retry 
+                OutPacket(packet, ThrottleOutPacketType.Task, true);
             }
 
+
+
             #endregion Packet Sending
+
         }
 
+        // hack.. dont use
+        public void SendPartFullUpdate(ISceneEntity ent, uint? parentID)
+        {
+            if (ent is SceneObjectPart)
+            {
+                SceneObjectPart part = (SceneObjectPart)ent;
+                ObjectUpdatePacket packet = (ObjectUpdatePacket)PacketPool.Instance.GetPacket(PacketType.ObjectUpdate);
+                packet.RegionData.RegionHandle = m_scene.RegionInfo.RegionHandle;
+                packet.RegionData.TimeDilation = 1;
+                packet.ObjectData = new ObjectUpdatePacket.ObjectDataBlock[1];
+
+                ObjectUpdatePacket.ObjectDataBlock blk = CreatePrimUpdateBlock(part, this.m_agentId);
+                if (parentID.HasValue)
+                {
+                    blk.ParentID = parentID.Value;
+                }
+
+                packet.ObjectData[0] = blk;
+
+                OutPacket(packet, ThrottleOutPacketType.Task, true);
+            }
+        }
+        
         public void ReprioritizeUpdates()
         {
             lock (m_entityUpdates.SyncRoot)