/// <summary>
/// Dequeues this instance.
/// </summary>
/// <returns></returns>
public TValue Dequeue()
{
bool isValueAssigned = false;
TValue value = default(TValue);
lock (_lock)
{
if (_count > 0)
{
do
{
if (_currentIndexMarker.Previous == null)
{
_currentIndexMarker = _currentIndexMarker.LowerPriorityIndexMarker;
}
else
{
value = _currentIndexMarker.Previous.Value;
isValueAssigned = true;
_currentIndexMarker.Previous = _currentIndexMarker.Previous.Previous;
if (_currentIndexMarker.Previous == null)
{
_currentIndexMarker.Last = null;
}
}
} while (_currentIndexMarker != null && !isValueAssigned);
//decrement the count
_count--;
}
}
return(value);
}
/// <summary>
/// Internal function for A* search.
/// </summary>
/// <param name="pq"></param>
/// <param name="destNode"></param>
/// <returns></returns>
private static AStarSearchProgress AStarFindPath(ref PriorityQueue <double, AStarSearchProgress> pq, Node destNode)
{
PriorityQueueItem <double, AStarSearchProgress> pqItem = pq.Pop();
if (pqItem != null)
{
double curWeight = pqItem.Priority;
AStarSearchProgress progress = pqItem.Item;
Node curNode = progress.CurNode;
if (object.ReferenceEquals(curNode, destNode))
{
return(progress);
}
else
{
List <Edge> edgeList = curNode.EdgeList;
foreach (Edge edge in edgeList)
{
if (!progress.IsNodeVisited(edge.Node))
{
double weight = curWeight + edge.Weight;
AStarSearchProgress newProgress = progress.Clone();
newProgress.Visit(edge);
newProgress.CurNode = edge.Node;
pq.Put(weight, newProgress);
}
}
}
}
return(null);
}
private void DoSignificantClientMovement(object o)
{
ISceneEntity[] entities = m_presence.Scene.Entities.GetEntities(m_presence.AbsolutePosition, m_presence.DrawDistance);
PriorityQueue <EntityUpdate, double> m_entsqueue = new PriorityQueue <EntityUpdate, double> (entities.Length);
// build a prioritized list of things we need to send
HashSet <ISceneEntity> NewGrpsInView = new HashSet <ISceneEntity> ();
foreach (ISceneEntity e in entities)
{
if (e != null)
{
if (e.IsDeleted)
{
continue;
}
//Check for culling here!
if (!Culler.ShowEntityToClient(m_presence, e))
{
continue; // if 2 far ignore
}
double priority = m_prioritizer.GetUpdatePriority(m_presence, e);
NewGrpsInView.Add(e);
if (lastGrpsInView.Contains(e))
{
continue;
}
//Send the root object first!
EntityUpdate rootupdate = new EntityUpdate(e.RootChild, PrimUpdateFlags.FullUpdate);
PriorityQueueItem <EntityUpdate, double> rootitem = new PriorityQueueItem <EntityUpdate, double> ();
rootitem.Value = rootupdate;
rootitem.Priority = priority;
m_entsqueue.Enqueue(rootitem);
foreach (ISceneChildEntity child in e.ChildrenEntities())
{
if (child == e.RootChild)
{
continue; //Already sent
}
EntityUpdate update = new EntityUpdate(child, PrimUpdateFlags.FullUpdate);
PriorityQueueItem <EntityUpdate, double> item = new PriorityQueueItem <EntityUpdate, double> ();
item.Value = update;
item.Priority = priority;
m_entsqueue.Enqueue(item);
}
}
}
entities = null;
lastGrpsInView.Clear();
lastGrpsInView.UnionWith(NewGrpsInView);
NewGrpsInView.Clear();
// send them
SendQueued(m_entsqueue);
}
public void Insert(Node value)
{
var item = new PriorityQueueItem(value, mItems.Count);
mItems.Add(item);
mHashSet.Add(value);
RepairHeapUpwards(item.mHeapIndex);
}
/// <summary>
/// Initializes a new instance of the <see cref = "PriorityQueue<TValue>" /> class.
/// </summary>
public PriorityQueue()
{
_lowerBound.HigherPriorityIndexMarker = _upperBound;
_upperBound.LowerPriorityIndexMarker = _lowerBound;
_priorityQueue.Add(double.MinValue, _lowerBound);
_priorityQueue.Add(double.MaxValue, _upperBound);
_lastIndexMarker = _upperBound;
_currentIndexMarker = _lowerBound;
}
public void GeneratePrimMst(double[,] matrix)
{
int s = 0;
int n = VertexList.Count;
ClearSolution();
Entry[] table = new Entry[n];
for (int v = 0; v < n; v++)
{
table[v] = new Entry(false, int.MaxValue, int.MaxValue);
}
table[s].distance = 0;
PriorityQueue <int, double> heap2 = new PriorityQueue <int, double>();
heap2.Enqueue(s, 0);
while (heap2.Count != 0)
{
PriorityQueueItem <int, double> pqitem = new PriorityQueueItem <int, double>();
pqitem = heap2.Dequeue();
int v0 = pqitem.Value;
if (!table[v0].known)
{
table[v0].known = true;
for (int i = 0; i < VertexList.Count; i++)
{
if (i != v0 && matrix[v0, i] > 0.0)
{
int v1 = i;
//Edge e = new Edge(VertexList[v0], VertexList[v1]);
double d = matrix[v0, i]; //e.Length;
if (!table[v1].known && table[v1].distance > d)
{
table[v1].distance = d;
table[v1].predecessor = v0;
heap2.Enqueue(v1, d);
}
}
}
}
}
for (int i = 0; i < VertexList.Count; i++)
{
if (table[i].predecessor != int.MaxValue)
{
int next = table[i].predecessor;
Edge e = new Edge(VertexList[i], VertexList[next]);
e.Length = matrix[i, next];
EdgeSolution.Add(e);
}
}
}
public int Compare(PriorityQueueItem <TValue> x, PriorityQueueItem <TValue> y)
{
if (x.Priority > y.Priority)
{
return(1);
}
if (x.Priority == y.Priority)
{
return(x.Value.GetHashCode() - y.Value.GetHashCode());
}
return(-1);
}
public void Solve()
{
IPriorityQueue <PriorityQueueItem> spots = priorityQueue; //Spots remaining to check
List <Coordinate> seen = new List <Coordinate>(); //Spots already seen. Dont add them again.
//Add the starting point to the graph.
spots.Insert(new PriorityQueueItem
{
priority = 0,
curr = graph.Start,
path = new List <Coordinate>()
{
graph.Start
}
});
PriorityQueueItem current = spots.ExtractMin(); //Get the min value from pqueue.
while (!current.curr.Equals(graph.End)) //Not to end yet.
{
List <Coordinate> adjs = graph.GetAdjacencies(current.curr); //Where all can I go?
foreach (Coordinate adj in adjs)
{
if (seen.Contains(adj)) //Already been here
{
continue;
}
//I could come here though
PriorityQueueItem new_spot = new PriorityQueueItem()
{
priority = current.path.Count + _heuristic.Score(graph, adj),
curr = adj,
path = new List <Coordinate>(current.path)
};
new_spot.path.Add(adj); //Path includes current node
spots.Insert(new_spot); //I'll check it
}
seen.Add(current.curr); //Just checked you.
current = spots.ExtractMin(); //Get next node.
}
path = current.path; //Found a path.
}
static void Main(string[] args)
{
PriorityQueue <AlarmEvent, AlarmEventType> pq =
new PriorityQueue <AlarmEvent, AlarmEventType>();
// Add a bunch of events to the queue
pq.Enqueue(new AlarmEvent(AlarmEventType.Test, "Testing 1"), AlarmEventType.Test);
pq.Enqueue(new AlarmEvent(AlarmEventType.Fire, "Fire alarm 1"), AlarmEventType.Fire);
pq.Enqueue(new AlarmEvent(AlarmEventType.Trouble, "Battery low"), AlarmEventType.Trouble);
pq.Enqueue(new AlarmEvent(AlarmEventType.Panic, "I've fallen and I can't get up!"), AlarmEventType.Panic);
pq.Enqueue(new AlarmEvent(AlarmEventType.Test, "Another test."), AlarmEventType.Test);
pq.Enqueue(new AlarmEvent(AlarmEventType.Alert, "Oops, I forgot the reset code."), AlarmEventType.Alert);
Console.WriteLine("The queue contains {0} events", pq.Count);
// Now remove the items in priority order
Console.WriteLine();
while (pq.Count > 0)
{
PriorityQueueItem <AlarmEvent, AlarmEventType> item = pq.Dequeue();
Console.WriteLine("{0}: {1}", item.Priority, item.Value.Message);
}
}
/// <summary>
/// Returns an enumerator that iterates through a collection.
/// </summary>
/// <returns>
/// An <see cref = "T:System.Collections.IEnumerator" /> object that can be used to iterate through the collection.
/// </returns>
/// <filterpriority>2</filterpriority>
IEnumerator <PriorityQueueItem <TValue> > IEnumerable <PriorityQueueItem <TValue> > .GetEnumerator()
{
List <PriorityQueueItem <TValue> > values = new List <PriorityQueueItem <TValue> >();
PriorityQueueItem <TValue> _marker = _upperBound;
PriorityQueueItem <TValue> _item = null;
while (_marker._lowerPriorityIndexMarker != null)
{
_item = _marker.Previous;
while (_item != null)
{
values.Add(_item);
_item = _item.Previous;
}
_marker = _marker._lowerPriorityIndexMarker;
}
return(new List <PriorityQueueItem <TValue> > .Enumerator());
}
/// <summary>
/// Processes the events.
/// </summary>
private void ProcessEvents()
{
while (true)
{
EventAction action = null;
lock (eventLock)
{
if (eventQueue.Count > 0)
{
PriorityQueueItem <EventAction, EventPriority> eventItem = eventQueue.Dequeue();
action = eventItem.Value;
if (action == null)
{
return;
}
}
}
if (action != null)
{
log.Info(string.Format("Processing events {0} from {1}", action.Notification, action.Computer));
// Start processing events
EventNotificationType notificationType = (EventNotificationType)StringEnum.Parse(typeof(EventNotificationType), action.Notification);
if (notificationType == EventNotificationType.NewMessage)
{
log.Info("New messages arrived");
RefreshMessageView(ViewAction.RefreshInbox);
}
}
else
{
eventTrigger.WaitOne(); // wait for events
}
}
}
public void GenerateEuclideanPrimMst()
{
int s = 0;
DateTime Start = DateTime.Now;
int n = VertexList.Count;
EdgeSolution.Clear();
Entry[] table = new Entry[n];
for (int v = 0; v < n; v++)
{
table[v] = new Entry(false, int.MaxValue, int.MaxValue);
}
table[s].distance = 0;
PriorityQueue<int, double> heap2 = new PriorityQueue<int, double>();
heap2.Enqueue(s, 0);
//List<pqueue> heap1 = new List<pqueue>();
//pqueue temp = new pqueue(s, 0);
//heap1.Add(temp);
//while (heap1.Count != 0)
while (heap2.Count != 0)
{
//int v0 = heap1[0].vtx;
//heap1.RemoveAt(0);
PriorityQueueItem<int, double> pqitem = new PriorityQueueItem<int, double>();
pqitem = heap2.Dequeue();
int v0 = pqitem.Value;
if (!table[v0].known)
{
table[v0].known = true;
for (int i = 0; i < VertexList.Count; i++)
{
if (i != v0)
{
int v1 = i;
Edge e = new Edge(VertexList[v0], VertexList[v1]);
double d = e.Length;
if (!table[v1].known && table[v1].distance > d)
{
table[v1].distance = d;
table[v1].predecessor = v0;
heap2.Enqueue(v1, d);
//heap2.cekPQ();
/*pqueue temp1 = new pqueue(v1, d);
int j;
//Sortingnya O(n) males bikin AVL TREE =P
for (j = 0; j < heap1.Count && heap1[j].dist < temp1.dist; j++){}
if (j == heap1.Count) heap1.Add(temp1);
else heap1.Insert(j, temp1);*/
//heap1.Sort(new pqueueCompare());
}
}
}
}
}
for (int i = 0; i < VertexList.Count; i++)
{
if (table[i].predecessor != int.MaxValue)
{
int next = table[i].predecessor;
Edge e = new Edge(VertexList[i], VertexList[next]);
EdgeSolution.Add(e);
}
}
Console.WriteLine((DateTime.Now - Start).TotalMilliseconds + " ms");
//this.VisitedVertex = VertexList.Count;
}
/// <summary>
/// Add the objects to the queue for which we need to send an update to the client
/// </summary>
/// <param name="part"></param>
public void QueuePartForUpdate(SceneObjectPart part, PrimUpdateFlags UpdateFlags)
{
double priority = m_prioritizer.GetUpdatePriority(m_presence.ControllingClient, part.ParentGroup);
EntityUpdate update = new EntityUpdate(part, UpdateFlags);
//Fix the version with the newest locked m_version
FixVersion(update);
PriorityQueueItem<EntityUpdate, double> item = new PriorityQueueItem<EntityUpdate, double>();
item.Priority = priority;
item.Value = update;
m_partsUpdateQueue.Enqueue(item);
//Make it check when the user comes around to it again
if (m_objectsInView.Contains(part.UUID))
m_objectsInView.Remove(part.UUID);
}
/// <summary>
/// This method is called by the LLUDPServer and should never be called by anyone else
/// It loops through the available updates and sends them out (no waiting)
/// </summary>
/// <param name="numUpdates">The number of updates to send</param>
public void SendPrimUpdates(int numUpdates)
{
if (m_inUse)
{
return;
}
m_inUse = true;
//This is for stats
int AgentMS = Util.EnvironmentTickCount();
#region New client entering the Scene, requires all objects in the Scene
///If we havn't started processing this client yet, we need to send them ALL the prims that we have in this Scene (and deal with culling as well...)
if (!m_SentInitialObjects)
{
m_SentInitialObjects = true;
//If they are not in this region, we check to make sure that we allow seeing into neighbors
if (!m_presence.IsChildAgent || (m_presence.Scene.RegionInfo.SeeIntoThisSimFromNeighbor) && Culler != null && m_prioritizer != null)
{
ISceneEntity[] entities = m_presence.Scene.Entities.GetEntities();
PriorityQueue <EntityUpdate, double> m_entsqueue = new PriorityQueue <EntityUpdate, double> (entities.Length);
// build a prioritized list of things we need to send
foreach (ISceneEntity e in entities)
{
if (e != null && e is SceneObjectGroup)
{
if (e.IsDeleted)
{
continue;
}
//Check for culling here!
if (!Culler.ShowEntityToClient(m_presence, e))
{
continue;
}
double priority = m_prioritizer.GetUpdatePriority(m_presence, e);
//Send the root object first!
EntityUpdate rootupdate = new EntityUpdate(e.RootChild, PrimUpdateFlags.FullUpdate);
PriorityQueueItem <EntityUpdate, double> rootitem = new PriorityQueueItem <EntityUpdate, double> ();
rootitem.Value = rootupdate;
rootitem.Priority = priority;
m_entsqueue.Enqueue(rootitem);
foreach (ISceneChildEntity child in e.ChildrenEntities())
{
if (child == e.RootChild)
{
continue; //Already sent
}
EntityUpdate update = new EntityUpdate(child, PrimUpdateFlags.FullUpdate);
PriorityQueueItem <EntityUpdate, double> item = new PriorityQueueItem <EntityUpdate, double> ();
item.Value = update;
item.Priority = priority;
m_entsqueue.Enqueue(item);
}
}
}
entities = null;
// send them
SendQueued(m_entsqueue);
}
}
lock (m_presenceUpdatesToSend)
{
int numToSend = (int)(numUpdates * PresenceSendPercentage);
//Send the numUpdates of them if that many
// if we don't have that many, we send as many as possible, then switch to objects
if (m_presenceUpdatesToSend.Count != 0)
{
int count = m_presenceUpdatesToSend.Count > numToSend ? numToSend : m_presenceUpdatesToSend.Count;
List <EntityUpdate> updates = new List <EntityUpdate> ();
for (int i = 0; i < count; i++)
{
updates.Add((EntityUpdate)m_presenceUpdatesToSend[0]);
m_presenceUpdatesToSend.RemoveAt(0);
}
//If we're first, we definitely got set, so we don't need to check this at all
m_ourPresenceHasUpdate = false;
m_presence.ControllingClient.SendPrimUpdate(updates);
}
}
lock (m_objectUpdatesToSend)
{
int numToSend = (int)(numUpdates * PrimSendPercentage);
if (m_objectUpdatesToSend.Count != 0)
{
int count = m_objectUpdatesToSend.Count > numToSend ? numToSend : m_objectUpdatesToSend.Count;
List <EntityUpdate> updates = new List <EntityUpdate> ();
for (int i = 0; i < count; i++)
{
updates.Add((EntityUpdate)m_objectUpdatesToSend[0]);
m_objectUpdatesToSend.RemoveAt(0);
}
m_presence.ControllingClient.SendPrimUpdate(updates);
}
}
//Add the time to the stats tracker
IAgentUpdateMonitor reporter = (IAgentUpdateMonitor)m_presence.Scene.RequestModuleInterface <IMonitorModule> ().GetMonitor(m_presence.Scene.RegionInfo.RegionID.ToString(), "Agent Update Count");
if (reporter != null)
{
reporter.AddAgentTime(Util.EnvironmentTickCountSubtract(AgentMS));
}
m_inUse = false;
}
/// <summary>
/// Enqueues the specified value.
/// </summary>
/// <param name = "value">The value.</param>
/// <param name = "priority">The priority.</param>
public void Enqueue(TValue value, double priority)
{
lock (_lock)
{
//add index marker
if (!_priorityQueue.ContainsKey(priority))
{
PriorityQueueItem <TValue> indexMarker = new PriorityQueueItem <TValue>(default(TValue), priority);
indexMarker.IsIndexMarker = true;
_priorityQueue.Add(priority, indexMarker);
if (priority > _lastIndexMarker.Priority)
{
do
{
_lastIndexMarker = _lastIndexMarker.HigherPriorityIndexMarker;
} while (_lastIndexMarker.HigherPriorityIndexMarker != null && _lastIndexMarker.Priority < priority);
indexMarker.HigherPriorityIndexMarker = _lastIndexMarker;
indexMarker.LowerPriorityIndexMarker = _lastIndexMarker.LowerPriorityIndexMarker;
_lastIndexMarker.LowerPriorityIndexMarker.HigherPriorityIndexMarker = indexMarker;
_lastIndexMarker.LowerPriorityIndexMarker = indexMarker;
}
else if (priority < _lastIndexMarker.Priority)
{
do
{
_lastIndexMarker = _lastIndexMarker.LowerPriorityIndexMarker;
} while (_lastIndexMarker.LowerPriorityIndexMarker != null && _lastIndexMarker.Priority > priority);
indexMarker.LowerPriorityIndexMarker = _lastIndexMarker;
indexMarker.HigherPriorityIndexMarker = _lastIndexMarker.HigherPriorityIndexMarker;
_lastIndexMarker.HigherPriorityIndexMarker.LowerPriorityIndexMarker = indexMarker;
_lastIndexMarker.HigherPriorityIndexMarker = indexMarker;
}
_lastIndexMarker = indexMarker;
}
//update the current index marker
if (priority > _currentIndexMarker.Priority)
{
_currentIndexMarker = _priorityQueue[priority];
}
//manage the list
PriorityQueueItem <TValue> priorityQueueItem = new PriorityQueueItem <TValue>(value, priority);
if (_priorityQueue[priority].Previous == null)
{
_priorityQueue[priority].Previous = priorityQueueItem;
_priorityQueue[priority].Last = priorityQueueItem;
}
else
{
_priorityQueue[priority].Last.Previous = priorityQueueItem;
_priorityQueue[priority].Last = priorityQueueItem;
}
//increment the count
_count++;
}
}
/// <summary>
/// Attempts to use the data provided in packetBuilder to recreate something useful. If we don't have enough data
/// yet that value is set in packetBuilder.
/// </summary>
/// <param name="packetBuilder">The <see cref="PacketBuilder"/> containing incoming cached data</param>
protected void IncomingPacketHandleHandOff(PacketBuilder packetBuilder)
{
int loopCounter = 0;
try
{
if (NetworkComms.LoggingEnabled)
{
NetworkComms.Logger.Trace(" ... checking for completed packet with " + packetBuilder.TotalBytesCached.ToString() + " bytes read.");
}
if (packetBuilder.TotalPartialPacketCount == 0)
{
throw new Exception("Executing IncomingPacketHandleHandOff when no packets exist in packetbuilder.");
}
//Loop until we are finished with this packetBuilder
while (true)
{
//If we have ended up with a null packet at the front, probably due to some form of concatenation we can pull it off here
//It is possible we have concatenation of several null packets along with real data so we loop until the firstByte is greater than 0
if (ConnectionInfo.ApplicationLayerProtocol == ApplicationLayerProtocolStatus.Enabled && packetBuilder.FirstByte() == 0)
{
#region Ignore Null Packet
if (NetworkComms.LoggingEnabled)
{
NetworkComms.Logger.Trace(" ... null packet removed in IncomingPacketHandleHandOff() from " + ConnectionInfo + ", loop index - " + loopCounter.ToString());
}
packetBuilder.ClearNTopBytes(1);
//Reset the expected bytes to 0 so that the next check starts from scratch
packetBuilder.TotalBytesExpected = 0;
//If we have run out of data completely then we can return immediately
if (packetBuilder.TotalBytesCached == 0)
{
return;
}
#endregion
}
else
{
int packetHeaderSize = 0;
PacketHeader topPacketHeader;
#region Set topPacketHeader
if (ConnectionInfo.ApplicationLayerProtocol == ApplicationLayerProtocolStatus.Enabled)
{
//First determine the expected size of a header packet
packetHeaderSize = packetBuilder.FirstByte() + 1;
//Do we have enough data to build a header?
if (packetBuilder.TotalBytesCached < packetHeaderSize)
{
if (NetworkComms.LoggingEnabled)
{
NetworkComms.Logger.Trace(" ... require " + packetHeaderSize + " bytes for packet header, only " + packetBuilder.TotalBytesCached + " bytes cached.");
}
//Set the expected number of bytes and then return
packetBuilder.TotalBytesExpected = packetHeaderSize;
return;
}
if (NetworkComms.LoggingEnabled)
{
NetworkComms.Logger.Trace(" ... deserializing header using " + packetHeaderSize + " bytes, " + packetBuilder.TotalBytesCached + " bytes cached.");
}
//We have enough for a header
using (MemoryStream headerStream = packetBuilder.ReadDataSection(1, packetHeaderSize - 1))
topPacketHeader = new PacketHeader(headerStream, NetworkComms.InternalFixedSendReceiveOptions);
}
else
{
topPacketHeader = new PacketHeader(Enum.GetName(typeof(ReservedPacketType), ReservedPacketType.Unmanaged), packetBuilder.TotalBytesCached);
}
#endregion
//Idiot test
if (topPacketHeader.PacketType == null)
{
throw new SerialisationException("packetType value in packetHeader should never be null");
}
//We can now use the header to establish if we have enough payload data
//First case is when we have not yet received enough data
if (packetBuilder.TotalBytesCached < packetHeaderSize + topPacketHeader.TotalPayloadSize)
{
if (NetworkComms.LoggingEnabled)
{
NetworkComms.Logger.Trace(" ... more data required for complete packet payload. Expecting " + (packetHeaderSize + topPacketHeader.TotalPayloadSize).ToString() + " total packet bytes.");
}
//Set the expected number of bytes and then return
packetBuilder.TotalBytesExpected = packetHeaderSize + topPacketHeader.TotalPayloadSize;
return;
}
//Second case is we have enough data
else if (packetBuilder.TotalBytesCached >= packetHeaderSize + topPacketHeader.TotalPayloadSize)
{
#region Handle Packet
//We can either have exactly the right amount or even more than we were expecting
//We may have too much data if we are sending high quantities and the packets have been concatenated
SendReceiveOptions incomingPacketSendReceiveOptions = IncomingPacketSendReceiveOptions(topPacketHeader);
if (NetworkComms.LoggingEnabled)
{
NetworkComms.Logger.Debug("Received packet of type '" + topPacketHeader.PacketType + "' from " + ConnectionInfo + ", containing " + packetHeaderSize.ToString() + " header bytes and " + topPacketHeader.TotalPayloadSize.ToString() + " payload bytes.");
}
bool isReservedPacketType = (topPacketHeader.PacketType != Enum.GetName(typeof(ReservedPacketType), ReservedPacketType.Unmanaged) &&
NetworkComms.ReservedPacketTypeNames.ContainsKey(topPacketHeader.PacketType));
//Get the packet sequence number if logging
string packetSeqNumStr = "";
if (NetworkComms.LoggingEnabled)
{
packetSeqNumStr = (topPacketHeader.ContainsOption(PacketHeaderLongItems.PacketSequenceNumber) ? ". pSeq#-" + topPacketHeader.GetOption(PacketHeaderLongItems.PacketSequenceNumber).ToString() + "." : "");
}
//Only reserved packet types get completed inline by default
if (isReservedPacketType)
{
#if WINDOWS_PHONE || NETFX_CORE
QueueItemPriority priority = QueueItemPriority.Normal;
#else
QueueItemPriority priority = (QueueItemPriority)Thread.CurrentThread.Priority;
#endif
PriorityQueueItem item = new PriorityQueueItem(priority, this, topPacketHeader, packetBuilder.ReadDataSection(packetHeaderSize, topPacketHeader.TotalPayloadSize), incomingPacketSendReceiveOptions);
if (NetworkComms.LoggingEnabled)
{
NetworkComms.Logger.Trace(" ... handling packet type '" + topPacketHeader.PacketType + "' inline. Loop index - " + loopCounter.ToString() + packetSeqNumStr);
}
NetworkComms.CompleteIncomingItemTask(item);
}
else
{
QueueItemPriority itemPriority = (incomingPacketSendReceiveOptions.Options.ContainsKey("ReceiveHandlePriority") ? (QueueItemPriority)Enum.Parse(typeof(QueueItemPriority), incomingPacketSendReceiveOptions.Options["ReceiveHandlePriority"]) : QueueItemPriority.Normal);
PriorityQueueItem item = new PriorityQueueItem(itemPriority, this, topPacketHeader, packetBuilder.ReadDataSection(packetHeaderSize, topPacketHeader.TotalPayloadSize), incomingPacketSendReceiveOptions);
//QueueItemPriority.Highest is the only priority that is executed inline
if (itemPriority == QueueItemPriority.Highest)
{
if (NetworkComms.LoggingEnabled)
{
NetworkComms.Logger.Trace(" ... handling packet type '" + topPacketHeader.PacketType + "' with priority HIGHEST inline. Loop index - " + loopCounter.ToString() + packetSeqNumStr);
}
NetworkComms.CompleteIncomingItemTask(item);
}
else
{
#if NETFX_CORE
NetworkComms.CommsThreadPool.EnqueueItem(item.Priority, NetworkComms.CompleteIncomingItemTask, item);
if (NetworkComms.LoggingEnabled)
{
NetworkComms.Logger.Trace(" ... added completed " + item.PacketHeader.PacketType + " packet to thread pool (Q:" + NetworkComms.CommsThreadPool.QueueCount.ToString() + ") with priority " + itemPriority.ToString() + ". Loop index=" + loopCounter.ToString() + packetSeqNumStr);
}
#else
int threadId = NetworkComms.CommsThreadPool.EnqueueItem(item.Priority, NetworkComms.CompleteIncomingItemTask, item);
if (NetworkComms.LoggingEnabled)
{
NetworkComms.Logger.Trace(" ... added completed " + item.PacketHeader.PacketType + " packet to thread pool (Q:" + NetworkComms.CommsThreadPool.QueueCount.ToString() + ", T:" + NetworkComms.CommsThreadPool.CurrentNumTotalThreads.ToString() + ", I:" + NetworkComms.CommsThreadPool.CurrentNumIdleThreads.ToString() + ") with priority " + itemPriority.ToString() + (threadId > 0 ? ". Selected threadId=" + threadId.ToString() : "") + ". Loop index=" + loopCounter.ToString() + packetSeqNumStr);
}
#endif
}
}
//We clear the bytes we have just handed off
if (NetworkComms.LoggingEnabled)
{
NetworkComms.Logger.Trace("Removing " + (packetHeaderSize + topPacketHeader.TotalPayloadSize).ToString() + " bytes from incoming packet builder from connection with " + ConnectionInfo + ".");
}
packetBuilder.ClearNTopBytes(packetHeaderSize + topPacketHeader.TotalPayloadSize);
//Reset the expected bytes to 0 so that the next check starts from scratch
packetBuilder.TotalBytesExpected = 0;
//If we have run out of data completely then we can return immediately
if (packetBuilder.TotalBytesCached == 0)
{
return;
}
#endregion
}
else
{
throw new CommunicationException("This should be impossible!");
}
}
loopCounter++;
}
}
catch (Exception ex)
{
//Any error, throw an exception.
if (NetworkComms.LoggingEnabled)
{
NetworkComms.Logger.Fatal("A fatal exception occurred in IncomingPacketHandleHandOff(), connection with " + ConnectionInfo + " be closed. See log file for more information.");
}
if (this is IPConnection)
{
//Log the exception in DOS protection if enabled
if (IPConnection.DOSProtection.Enabled && ConnectionInfo.RemoteEndPoint.GetType() == typeof(IPEndPoint))
{
IPConnection.DOSProtection.LogMalformedData(ConnectionInfo.RemoteIPEndPoint.Address);
}
}
LogTools.LogException(ex, "CommsError", "A fatal exception occurred in IncomingPacketHandleHandOff(), connection with " + ConnectionInfo + " be closed. Loop counter " + loopCounter.ToString() + ". Packet builder contained " + packetBuilder.TotalBytesCached + " total cached bytes.");
CloseConnection(true, 45);
}
}
/// <summary>
/// This method is called by the LLUDPServer and should never be called by anyone else
/// It loops through the available updates and sends them out (no waiting)
/// </summary>
/// <param name="numUpdates">The number of updates to send</param>
public void SendPrimUpdates (int numPrimUpdates, int numAvaUpdates)
{
if (m_inUse || ((ScenePresence)m_presence).IsInTransit)
return;
if (m_numberOfLoops < NUMBER_OF_LOOPS_TO_WAIT) //Wait for the client to finish connecting fully before sending out bunches of updates
{
m_numberOfLoops++;
return;
}
m_inUse = true;
//This is for stats
int AgentMS = Util.EnvironmentTickCount ();
#region New client entering the Scene, requires all objects in the Scene
///If we havn't started processing this client yet, we need to send them ALL the prims that we have in this Scene (and deal with culling as well...)
if (!m_SentInitialObjects && m_presence.DrawDistance != 0.0f)
{
//If they are not in this region, we check to make sure that we allow seeing into neighbors
if (!m_presence.IsChildAgent || (m_presence.Scene.RegionInfo.SeeIntoThisSimFromNeighbor) && m_prioritizer != null)
{
m_SentInitialObjects = true;
ISceneEntity[] entities = m_presence.Scene.Entities.GetEntities ();
PriorityQueue<EntityUpdate, double> m_entsqueue = new PriorityQueue<EntityUpdate, double> (entities.Length, DoubleComparer);
List<ISceneEntity> NewGrpsInView = new List<ISceneEntity> ();
// build a prioritized list of things we need to send
foreach (ISceneEntity e in entities)
{
if (e != null && e is SceneObjectGroup)
{
if (e.IsDeleted)
continue;
if (lastGrpsInView.Contains (e))
continue;
//Check for culling here!
if (Culler != null)
{
if (!Culler.ShowEntityToClient (m_presence, e))
continue;
NewGrpsInView.Add (e);
}
//Send the root object first!
EntityUpdate rootupdate = new EntityUpdate (e.RootChild, PrimUpdateFlags.FullUpdate);
PriorityQueueItem<EntityUpdate, double> rootitem = new PriorityQueueItem<EntityUpdate, double> ();
rootitem.Value = rootupdate;
rootitem.Priority = m_prioritizer.GetUpdatePriority (m_presence, e.RootChild);
m_entsqueue.Enqueue (rootitem);
foreach (ISceneChildEntity child in e.ChildrenEntities ())
{
if (child == e.RootChild)
continue; //Already sent
EntityUpdate update = new EntityUpdate (child, PrimUpdateFlags.ForcedFullUpdate);
PriorityQueueItem<EntityUpdate, double> item = new PriorityQueueItem<EntityUpdate, double> ();
item.Value = update;
item.Priority = m_prioritizer.GetUpdatePriority (m_presence, child);
m_entsqueue.Enqueue (item);
}
}
}
//Merge the last seen lists
lastGrpsInView.UnionWith (NewGrpsInView);
NewGrpsInView.Clear ();
entities = null;
// send them
SendQueued (m_entsqueue);
}
}
int presenceNumToSend = numAvaUpdates;
lock (m_presenceUpdatesToSend)
{
//Send the numUpdates of them if that many
// if we don't have that many, we send as many as possible, then switch to objects
if (m_presenceUpdatesToSend.Count != 0)
{
try
{
int count = m_presenceUpdatesToSend.Count > presenceNumToSend ? presenceNumToSend : m_presenceUpdatesToSend.Count;
List<EntityUpdate> updates = new List<EntityUpdate> ();
for (int i = 0; i < count; i++)
{
EntityUpdate update = ((EntityUpdate)m_presenceUpdatesToSend[0]);
if (m_EntitiesInPacketQueue.Contains (update.Entity.UUID))
{
m_presenceUpdatesToSend.RemoveAt (0);
m_presenceUpdatesToSend.Insert (m_presenceUpdatesToSend.Count, update.Entity.UUID, update);
continue;
}
updates.Add (update);
m_EntitiesInPacketQueue.Add (update.Entity.UUID);
m_presenceUpdatesToSend.RemoveAt (0);
}
if (updates.Count != 0)
{
presenceNumToSend -= updates.Count;
//Make sure we don't have an update for us
if (updates[0].Entity.UUID == m_presence.UUID)
m_ourPresenceHasUpdate = false;
m_presence.ControllingClient.SendAvatarUpdate (updates);
}
}
catch (Exception ex)
{
m_log.WarnFormat ("[SceneViewer]: Exception while running presence loop: {0}", ex.ToString ());
}
}
}
lock (m_presenceAnimationsToSend)
{
//Send the numUpdates of them if that many
// if we don't have that many, we send as many as possible, then switch to objects
if (m_presenceAnimationsToSend.Count != 0 && presenceNumToSend > 0)
{
try
{
int count = m_presenceAnimationsToSend.Count > presenceNumToSend ? presenceNumToSend : m_presenceAnimationsToSend.Count;
for (int i = 0; i < count; i++)
{
AnimationGroup update = ((AnimationGroup)m_presenceAnimationsToSend[0]);
if (m_AnimationsInPacketQueue.Contains (update.AvatarID))
{
m_presenceAnimationsToSend.RemoveAt (0);
m_presenceAnimationsToSend.Insert (m_presenceAnimationsToSend.Count, update.AvatarID, update);
continue;
}
m_AnimationsInPacketQueue.Add (update.AvatarID);
m_presenceAnimationsToSend.RemoveAt (0);
m_presence.ControllingClient.SendAnimations (update);
}
}
catch (Exception ex)
{
m_log.WarnFormat ("[SceneViewer]: Exception while running presence loop: {0}", ex.ToString ());
}
}
}
int primsNumToSend = numPrimUpdates;
lock (m_objectPropertiesToSend)
{
//Send the numUpdates of them if that many
// if we don't have that many, we send as many as possible, then switch to objects
if (m_objectPropertiesToSend.Count != 0)
{
try
{
List<IEntity> entities = new List<IEntity> ();
int count = m_objectPropertiesToSend.Count > primsNumToSend ? primsNumToSend : m_objectPropertiesToSend.Count;
for (int i = 0; i < count; i++)
{
ISceneChildEntity entity = ((ISceneChildEntity)m_objectPropertiesToSend[0]);
if (m_PropertiesInPacketQueue.Contains (entity.UUID))
{
m_objectPropertiesToSend.RemoveAt (0);
m_objectPropertiesToSend.Insert (m_objectPropertiesToSend.Count, entity.UUID, entity);
continue;
}
m_PropertiesInPacketQueue.Add (entity.UUID);
m_objectPropertiesToSend.RemoveAt (0);
entities.Add (entity);
}
if (entities.Count > 0)
{
primsNumToSend -= entities.Count;
m_presence.ControllingClient.SendObjectPropertiesReply (entities);
}
}
catch (Exception ex)
{
m_log.WarnFormat ("[SceneViewer]: Exception while running presence loop: {0}", ex.ToString ());
}
}
}
lock (m_objectUpdatesToSend)
{
if (m_objectUpdatesToSend.Count != 0)
{
try
{
int count = m_objectUpdatesToSend.Count > primsNumToSend ? primsNumToSend : m_objectUpdatesToSend.Count;
List<EntityUpdate> updates = new List<EntityUpdate> ();
for (int i = 0; i < count; i++)
{
EntityUpdate update = ((EntityUpdate)m_objectUpdatesToSend[0]);
if (m_EntitiesInPacketQueue.Contains (update.Entity.UUID))
{
m_objectUpdatesToSend.RemoveAt (0);
m_objectUpdatesToSend.Insert (m_objectUpdatesToSend.Count, update.Entity.UUID, update);
continue;
}
updates.Add (update);
m_EntitiesInPacketQueue.Add (update.Entity.UUID);
m_objectUpdatesToSend.RemoveAt (0);
}
m_presence.ControllingClient.SendPrimUpdate (updates);
}
catch (Exception ex)
{
m_log.WarnFormat ("[SceneViewer]: Exception while running object loop: {0}", ex.ToString ());
}
}
}
//Add the time to the stats tracker
IAgentUpdateMonitor reporter = (IAgentUpdateMonitor)m_presence.Scene.RequestModuleInterface<IMonitorModule> ().GetMonitor (m_presence.Scene.RegionInfo.RegionID.ToString (), "Agent Update Count");
if (reporter != null)
reporter.AddAgentTime (Util.EnvironmentTickCountSubtract (AgentMS));
m_inUse = false;
}
/// <summary>
/// This loops through all of the lists that we have for the client
/// as well as checking whether the client has ever entered the sim before
/// and sending the needed updates to them if they have just entered.
/// </summary>
public void SendPrimUpdates()
{
if (m_inUse)
return;
m_inUse = true;
//This is for stats
int AgentMS = Util.EnvironmentTickCount();
#region New client entering the Scene, requires all objects in the Scene
///If we havn't started processing this client yet, we need to send them ALL the prims that we have in this Scene (and deal with culling as well...)
if (!m_SentInitialObjects)
{
m_SentInitialObjects = true;
//If they are not in this region, we check to make sure that we allow seeing into neighbors
if (!m_presence.IsChildAgent || (m_presence.Scene.RegionInfo.SeeIntoThisSimFromNeighbor))
{
EntityBase[] entities = m_presence.Scene.Entities.GetEntities();
//Use the PriorityQueue so that we can send them in the correct order
PriorityQueue<EntityUpdate, double> entityUpdates = new PriorityQueue<EntityUpdate, double>(entities.Length);
foreach (EntityBase e in entities)
{
if (e != null && e is SceneObjectGroup)
{
SceneObjectGroup grp = (SceneObjectGroup)e;
//Check for culling here!
if (!CheckForCulling(grp))
continue;
//Get the correct priority and add to the queue
double priority = m_prioritizer.GetUpdatePriority(m_presence.ControllingClient, grp);
PriorityQueueItem<EntityUpdate, double> item = new PriorityQueueItem<EntityUpdate,double>(
new EntityUpdate(grp, PrimUpdateFlags.FullUpdate), priority);
entityUpdates.Enqueue(item); //New object, send full
}
}
entities = null;
//Send all the updates to the client
PriorityQueueItem<EntityUpdate, double> update;
while (entityUpdates.TryDequeue(out update))
{
SendUpdate(PrimUpdateFlags.FullUpdate, (SceneObjectGroup)update.Value.Entity);
}
}
}
#endregion
#region Update loop that sends objects that have been recently added to the queue
//Pull the parts out into a list first so that we don't lock the queue for too long
Dictionary<UUID, List<EntityUpdate>> m_parentUpdates = new Dictionary<UUID, List<EntityUpdate>>();
lock (m_partsUpdateQueue)
{
lock (m_removeNextUpdateOf)
{
PriorityQueueItem<EntityUpdate, double> update;
while (m_partsUpdateQueue.TryDequeue(out update))
{
if (update.Value == null)
continue;
//Make sure not to send deleted or null objects
if (((SceneObjectPart)update.Value.Entity).ParentGroup == null || ((SceneObjectPart)update.Value.Entity).ParentGroup.IsDeleted)
continue;
//Make sure we are not supposed to remove it
if (m_removeNextUpdateOf.ContainsKey(update.Value.Entity.LocalId))
{
if (update.Value.Version > m_removeNextUpdateOf[update.Value.Entity.LocalId])
{
//This update is newer, let it go on by
}
else //Not newer, should be removed Note: if this is the same version, its the update we were supposed to remove... so we do NOT do >= above
continue;
}
//Make sure we are not supposed to remove it
if (m_removeUpdateOf.Contains(update.Value.Entity.LocalId))
continue;
if (!m_parentUpdates.ContainsKey(((SceneObjectPart)update.Value.Entity).ParentGroup.UUID))
m_parentUpdates.Add(((SceneObjectPart)update.Value.Entity).ParentGroup.UUID, new List<EntityUpdate>());
m_parentUpdates[((SceneObjectPart)update.Value.Entity).ParentGroup.UUID].Add(update.Value);
}
m_removeNextUpdateOf.Clear();
}
}
//Now loop through the list and send the updates
foreach (UUID ParentID in m_parentUpdates.Keys)
{
//Sort by LinkID
m_parentUpdates[ParentID].Sort(linkSetSorter);
foreach (EntityUpdate update in m_parentUpdates[ParentID])
{
SceneObjectPart part = ((SceneObjectPart)update.Entity);
//Check for culling here!
if (!CheckForCulling(part.ParentGroup))
continue;
// Attachment handling. Attachments are 'special' and we have to send the full group update when we send updates
if (part.ParentGroup.RootPart.Shape.PCode == 9 && part.ParentGroup.RootPart.Shape.State != 0)
{
if (part != part.ParentGroup.RootPart)
continue;
//Check to make sure this attachment is not a hud. Attachments that are huds are
// ONLY sent to the owner, noone else!
if (
(
part.ParentGroup.RootPart.Shape.State == (byte)AttachmentPoint.HUDBottom ||
part.ParentGroup.RootPart.Shape.State == (byte)AttachmentPoint.HUDBottomLeft ||
part.ParentGroup.RootPart.Shape.State == (byte)AttachmentPoint.HUDBottomRight ||
part.ParentGroup.RootPart.Shape.State == (byte)AttachmentPoint.HUDCenter ||
part.ParentGroup.RootPart.Shape.State == (byte)AttachmentPoint.HUDCenter2 ||
part.ParentGroup.RootPart.Shape.State == (byte)AttachmentPoint.HUDTop ||
part.ParentGroup.RootPart.Shape.State == (byte)AttachmentPoint.HUDTopLeft ||
part.ParentGroup.RootPart.Shape.State == (byte)AttachmentPoint.HUDTopRight
)
&&
part.OwnerID != m_presence.UUID)
continue;
SendUpdate(update.Flags, part.ParentGroup);
continue;
}
SendUpdate(part,
m_presence.GenerateClientFlags(part), update.Flags);
}
}
#endregion
//Add the time to the stats tracker
IAgentUpdateMonitor reporter = (IAgentUpdateMonitor)m_presence.Scene.RequestModuleInterface<IMonitorModule>().GetMonitor(m_presence.Scene.RegionInfo.RegionID.ToString(), "Agent Update Count");
if (reporter != null)
reporter.AddAgentTime(Util.EnvironmentTickCountSubtract(AgentMS));
m_inUse = false;
}
private void DoSignificantClientMovement (object o)
{
ISceneEntity[] entities = m_presence.Scene.Entities.GetEntities (m_presence.AbsolutePosition, m_presence.DrawDistance);
PriorityQueue<EntityUpdate, double> m_entsqueue = new PriorityQueue<EntityUpdate, double> (entities.Length);
// build a prioritized list of things we need to send
HashSet<ISceneEntity> NewGrpsInView = new HashSet<ISceneEntity> ();
foreach (ISceneEntity e in entities)
{
if (e != null)
{
if (e.IsDeleted)
continue;
//Check for culling here!
if (!Culler.ShowEntityToClient(m_presence, e))
continue; // if 2 far ignore
double priority = m_prioritizer.GetUpdatePriority (m_presence, e);
NewGrpsInView.Add (e);
if (lastGrpsInView.Contains (e))
continue;
//Send the root object first!
EntityUpdate rootupdate = new EntityUpdate (e.RootChild, PrimUpdateFlags.FullUpdate);
PriorityQueueItem<EntityUpdate, double> rootitem = new PriorityQueueItem<EntityUpdate, double> ();
rootitem.Value = rootupdate;
rootitem.Priority = priority;
m_entsqueue.Enqueue (rootitem);
foreach (ISceneChildEntity child in e.ChildrenEntities ())
{
if (child == e.RootChild)
continue; //Already sent
EntityUpdate update = new EntityUpdate (child, PrimUpdateFlags.FullUpdate);
PriorityQueueItem<EntityUpdate, double> item = new PriorityQueueItem<EntityUpdate, double> ();
item.Value = update;
item.Priority = priority;
m_entsqueue.Enqueue (item);
}
}
}
entities = null;
lastGrpsInView.Clear ();
lastGrpsInView.UnionWith (NewGrpsInView);
NewGrpsInView.Clear ();
// send them
SendQueued (m_entsqueue);
}
/// <summary>
/// This method is called by the LLUDPServer and should never be called by anyone else
/// It loops through the available updates and sends them out (no waiting)
/// </summary>
/// <param name="numUpdates">The number of updates to send</param>
public void SendPrimUpdates (int numUpdates)
{
if (m_inUse)
return;
m_inUse = true;
//This is for stats
int AgentMS = Util.EnvironmentTickCount ();
#region New client entering the Scene, requires all objects in the Scene
///If we havn't started processing this client yet, we need to send them ALL the prims that we have in this Scene (and deal with culling as well...)
if (!m_SentInitialObjects && m_presence.DrawDistance != 0.0f)
{
m_SentInitialObjects = true;
//If they are not in this region, we check to make sure that we allow seeing into neighbors
if (!m_presence.IsChildAgent || (m_presence.Scene.RegionInfo.SeeIntoThisSimFromNeighbor) && Culler != null && m_prioritizer != null)
{
ISceneEntity[] entities = m_presence.Scene.Entities.GetEntities ();
PriorityQueue<EntityUpdate, double> m_entsqueue = new PriorityQueue<EntityUpdate, double> (entities.Length);
// build a prioritized list of things we need to send
foreach (ISceneEntity e in entities)
{
if (e != null && e is SceneObjectGroup)
{
if (e.IsDeleted)
continue;
//Check for culling here!
if (!Culler.ShowEntityToClient (m_presence, e))
continue;
double priority = m_prioritizer.GetUpdatePriority (m_presence, e);
//Send the root object first!
EntityUpdate rootupdate = new EntityUpdate (e.RootChild, PrimUpdateFlags.FullUpdate);
PriorityQueueItem<EntityUpdate, double> rootitem = new PriorityQueueItem<EntityUpdate, double> ();
rootitem.Value = rootupdate;
rootitem.Priority = priority;
m_entsqueue.Enqueue (rootitem);
foreach (ISceneChildEntity child in e.ChildrenEntities ())
{
if (child == e.RootChild)
continue; //Already sent
EntityUpdate update = new EntityUpdate (child, PrimUpdateFlags.FullUpdate);
PriorityQueueItem<EntityUpdate, double> item = new PriorityQueueItem<EntityUpdate, double> ();
item.Value = update;
item.Priority = priority;
m_entsqueue.Enqueue (item);
}
}
}
entities = null;
// send them
SendQueued (m_entsqueue);
}
}
int numberSent = 0;
int presenceNumToSend = (int)(numUpdates * PresenceSendPercentage);
lock (m_presenceUpdatesToSend)
{
//Send the numUpdates of them if that many
// if we don't have that many, we send as many as possible, then switch to objects
if (m_presenceUpdatesToSend.Count != 0)
{
int count = m_presenceUpdatesToSend.Count > presenceNumToSend ? presenceNumToSend : m_presenceUpdatesToSend.Count;
List<EntityUpdate> updates = new List<EntityUpdate> ();
for (int i = 0; i < count; i++)
{
updates.Add ((EntityUpdate)m_presenceUpdatesToSend[0]);
m_presenceUpdatesToSend.RemoveAt (0);
}
//If we're first, we definitely got set, so we don't need to check this at all
m_ourPresenceHasUpdate = false;
m_presence.ControllingClient.SendPrimUpdate (updates);
}
}
lock (m_objectUpdatesToSend)
{
numberSent = presenceNumToSend - numberSent;
int numToSend = (int)(numUpdates * PrimSendPercentage) + numberSent; //If we didn't send that many presence updates, send a few more
if (m_objectUpdatesToSend.Count != 0)
{
int count = m_objectUpdatesToSend.Count > numToSend ? numToSend : m_objectUpdatesToSend.Count;
List<EntityUpdate> updates = new List<EntityUpdate> ();
for (int i = 0; i < count; i++)
{
updates.Add ((EntityUpdate)m_objectUpdatesToSend[0]);
m_objectUpdatesToSend.RemoveAt (0);
}
m_presence.ControllingClient.SendPrimUpdate (updates);
}
}
//Add the time to the stats tracker
IAgentUpdateMonitor reporter = (IAgentUpdateMonitor)m_presence.Scene.RequestModuleInterface<IMonitorModule> ().GetMonitor (m_presence.Scene.RegionInfo.RegionID.ToString (), "Agent Update Count");
if (reporter != null)
reporter.AddAgentTime (Util.EnvironmentTickCountSubtract (AgentMS));
m_inUse = false;
}
public static int Compare(PriorityQueueItem <EntityUpdate, int> x, PriorityQueueItem <EntityUpdate, int> y)
{
return(x._priority.CompareTo(y._priority));
}
public void GeneratePrimMst(double[,] matrix)
{
int s = 0;
int n = VertexList.Count;
ClearSolution();
Entry[] table = new Entry[n];
for (int v = 0; v < n; v++)
{
table[v] = new Entry(false, int.MaxValue, int.MaxValue);
}
table[s].distance = 0;
PriorityQueue<int, double> heap2 = new PriorityQueue<int, double>();
heap2.Enqueue(s, 0);
while (heap2.Count != 0)
{
PriorityQueueItem<int, double> pqitem = new PriorityQueueItem<int, double>();
pqitem = heap2.Dequeue();
int v0 = pqitem.Value;
if (!table[v0].known)
{
table[v0].known = true;
for (int i = 0; i < VertexList.Count; i++)
{
if (i != v0 && matrix[v0,i] > 0.0)
{
int v1 = i;
//Edge e = new Edge(VertexList[v0], VertexList[v1]);
double d = matrix[v0, i]; //e.Length;
if (!table[v1].known && table[v1].distance > d)
{
table[v1].distance = d;
table[v1].predecessor = v0;
heap2.Enqueue(v1, d);
}
}
}
}
}
for (int i = 0; i < VertexList.Count; i++)
{
if (table[i].predecessor != int.MaxValue)
{
int next = table[i].predecessor;
Edge e = new Edge(VertexList[i], VertexList[next]);
e.Length = matrix[i, next];
EdgeSolution.Add(e);
}
}
}
public void GenerateEuclideanPrimMst()
{
int s = 0;
DateTime Start = DateTime.Now;
int n = VertexList.Count;
EdgeSolution.Clear();
Entry[] table = new Entry[n];
for (int v = 0; v < n; v++)
{
table[v] = new Entry(false, int.MaxValue, int.MaxValue);
}
table[s].distance = 0;
PriorityQueue <int, double> heap2 = new PriorityQueue <int, double>();
heap2.Enqueue(s, 0);
//List<pqueue> heap1 = new List<pqueue>();
//pqueue temp = new pqueue(s, 0);
//heap1.Add(temp);
//while (heap1.Count != 0)
while (heap2.Count != 0)
{
//int v0 = heap1[0].vtx;
//heap1.RemoveAt(0);
PriorityQueueItem <int, double> pqitem = new PriorityQueueItem <int, double>();
pqitem = heap2.Dequeue();
int v0 = pqitem.Value;
if (!table[v0].known)
{
table[v0].known = true;
for (int i = 0; i < VertexList.Count; i++)
{
if (i != v0)
{
int v1 = i;
Edge e = new Edge(VertexList[v0], VertexList[v1]);
double d = e.Length;
if (!table[v1].known && table[v1].distance > d)
{
table[v1].distance = d;
table[v1].predecessor = v0;
heap2.Enqueue(v1, d);
//heap2.cekPQ();
/*pqueue temp1 = new pqueue(v1, d);
* int j;
* //Sortingnya O(n) males bikin AVL TREE =P
* for (j = 0; j < heap1.Count && heap1[j].dist < temp1.dist; j++){}
* if (j == heap1.Count) heap1.Add(temp1);
* else heap1.Insert(j, temp1);*/
//heap1.Sort(new pqueueCompare());
}
}
}
}
}
for (int i = 0; i < VertexList.Count; i++)
{
if (table[i].predecessor != int.MaxValue)
{
int next = table[i].predecessor;
Edge e = new Edge(VertexList[i], VertexList[next]);
EdgeSolution.Add(e);
}
}
Console.WriteLine((DateTime.Now - Start).TotalMilliseconds + " ms");
//this.VisitedVertex = VertexList.Count;
}
private void DoSignificantClientMovement (object o)
{
ISceneEntity[] entities = m_presence.Scene.Entities.GetEntities (m_presence.AbsolutePosition, m_presence.DrawDistance * 3);
PriorityQueue<EntityUpdate, double> m_entsqueue = new PriorityQueue<EntityUpdate, double> (entities.Length, DoubleComparer);
// build a prioritized list of things we need to send
HashSet<ISceneEntity> NewGrpsInView = new HashSet<ISceneEntity> ();
foreach (ISceneEntity e in entities)
{
if (e != null)
{
if (e.IsDeleted)
continue;
if (lastGrpsInView.Contains (e)) //If we've already sent it, don't send it again
continue;
if (Culler != null)
{
if (!Culler.ShowEntityToClient (m_presence, e))
continue;
NewGrpsInView.Add (e);
}
//Send the root object first!
EntityUpdate rootupdate = new EntityUpdate (e.RootChild, PrimUpdateFlags.ForcedFullUpdate);
PriorityQueueItem<EntityUpdate, double> rootitem = new PriorityQueueItem<EntityUpdate, double> ();
rootitem.Value = rootupdate;
rootitem.Priority = m_prioritizer.GetUpdatePriority (m_presence, e.RootChild);
m_entsqueue.Enqueue (rootitem);
foreach (ISceneChildEntity child in e.ChildrenEntities ())
{
if (child == e.RootChild)
continue; //Already sent
EntityUpdate update = new EntityUpdate (child, PrimUpdateFlags.FullUpdate);
PriorityQueueItem<EntityUpdate, double> item = new PriorityQueueItem<EntityUpdate, double> ();
item.Value = update;
item.Priority = m_prioritizer.GetUpdatePriority (m_presence, child);
m_entsqueue.Enqueue (item);
}
}
}
entities = null;
lastGrpsInView.UnionWith (NewGrpsInView);
NewGrpsInView.Clear ();
// send them
SendQueued (m_entsqueue);
HashSet<IScenePresence> NewPresencesInView = new HashSet<IScenePresence>();
//Check for scenepresences as well
IScenePresence[] presences = m_presence.Scene.Entities.GetPresences(m_presence.AbsolutePosition, m_presence.DrawDistance);
foreach (IScenePresence presence in presences)
{
if (presence != null && presence.UUID != m_presence.UUID)
{
//Check for culling here!
if (!Culler.ShowEntityToClient(m_presence, presence))
continue; // if 2 far ignore
NewPresencesInView.Add (presence);
if (lastPresencesInView.Contains (presence))
continue; //Don't resend the update
SendFullUpdateForPresence (presence);
}
}
presences = null;
lastPresencesInView.UnionWith(NewPresencesInView);
NewPresencesInView.Clear();
}
