diff options
author | unknown | 2010-05-12 15:59:48 -0700 |
---|---|---|
committer | unknown | 2010-05-12 15:59:48 -0700 |
commit | bf5c81d77e492cd6df5517ecab32cd64168b01c2 (patch) | |
tree | ecbbfded19609dc8bcd39c0a8adea705c192fdb3 /OpenSim/Region/ClientStack/LindenUDP/LLClientView.cs | |
parent | Removed the unreferenced MaxPrimsPerFrame from OpenSim.ini.example (diff) | |
download | opensim-SC_OLD-bf5c81d77e492cd6df5517ecab32cd64168b01c2.zip opensim-SC_OLD-bf5c81d77e492cd6df5517ecab32cd64168b01c2.tar.gz opensim-SC_OLD-bf5c81d77e492cd6df5517ecab32cd64168b01c2.tar.bz2 opensim-SC_OLD-bf5c81d77e492cd6df5517ecab32cd64168b01c2.tar.xz |
* Initial commit of the slimupdates2 rewrite. This pass maintains the original behavior of avatar update sending and has a simplified set of IClientAPI methods for sending avatar/prim updates
Diffstat (limited to '')
-rw-r--r-- | OpenSim/Region/ClientStack/LindenUDP/LLClientView.cs | 627 |
1 files changed, 300 insertions, 327 deletions
diff --git a/OpenSim/Region/ClientStack/LindenUDP/LLClientView.cs b/OpenSim/Region/ClientStack/LindenUDP/LLClientView.cs index 1f3582c..6154da4 100644 --- a/OpenSim/Region/ClientStack/LindenUDP/LLClientView.cs +++ b/OpenSim/Region/ClientStack/LindenUDP/LLClientView.cs | |||
@@ -50,43 +50,17 @@ using Nini.Config; | |||
50 | 50 | ||
51 | namespace OpenSim.Region.ClientStack.LindenUDP | 51 | namespace OpenSim.Region.ClientStack.LindenUDP |
52 | { | 52 | { |
53 | #region Enums | 53 | public class EntityUpdate |
54 | |||
55 | /// <summary> | ||
56 | /// Specifies the fields that have been changed when sending a prim or | ||
57 | /// avatar update | ||
58 | /// </summary> | ||
59 | [Flags] | ||
60 | public enum PrimUpdateFlags : uint | ||
61 | { | 54 | { |
62 | None = 0, | 55 | public ISceneEntity Entity; |
63 | AttachmentPoint = 1 << 0, | 56 | public PrimUpdateFlags Flags; |
64 | Material = 1 << 1, | ||
65 | ClickAction = 1 << 2, | ||
66 | Scale = 1 << 3, | ||
67 | ParentID = 1 << 4, | ||
68 | PrimFlags = 1 << 5, | ||
69 | PrimData = 1 << 6, | ||
70 | MediaURL = 1 << 7, | ||
71 | ScratchPad = 1 << 8, | ||
72 | Textures = 1 << 9, | ||
73 | TextureAnim = 1 << 10, | ||
74 | NameValue = 1 << 11, | ||
75 | Position = 1 << 12, | ||
76 | Rotation = 1 << 13, | ||
77 | Velocity = 1 << 14, | ||
78 | Acceleration = 1 << 15, | ||
79 | AngularVelocity = 1 << 16, | ||
80 | CollisionPlane = 1 << 17, | ||
81 | Text = 1 << 18, | ||
82 | Particles = 1 << 19, | ||
83 | ExtraData = 1 << 20, | ||
84 | Sound = 1 << 21, | ||
85 | Joint = 1 << 22, | ||
86 | FullUpdate = UInt32.MaxValue | ||
87 | } | ||
88 | 57 | ||
89 | #endregion Enums | 58 | public EntityUpdate(ISceneEntity entity, PrimUpdateFlags flags) |
59 | { | ||
60 | Entity = entity; | ||
61 | Flags = flags; | ||
62 | } | ||
63 | } | ||
90 | 64 | ||
91 | public delegate bool PacketMethod(IClientAPI simClient, Packet packet); | 65 | public delegate bool PacketMethod(IClientAPI simClient, Packet packet); |
92 | 66 | ||
@@ -350,9 +324,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP | |||
350 | private readonly IGroupsModule m_GroupsModule; | 324 | private readonly IGroupsModule m_GroupsModule; |
351 | 325 | ||
352 | private int m_cachedTextureSerial; | 326 | private int m_cachedTextureSerial; |
353 | protected PriorityQueue<double, ImprovedTerseObjectUpdatePacket.ObjectDataBlock> m_avatarTerseUpdates; | 327 | private PriorityQueue<double, EntityUpdate> m_entityUpdates; |
354 | private PriorityQueue<double, ImprovedTerseObjectUpdatePacket.ObjectDataBlock> m_primTerseUpdates; | ||
355 | private PriorityQueue<double, ObjectUpdatePacket.ObjectDataBlock> m_primFullUpdates; | ||
356 | 328 | ||
357 | /// <value> | 329 | /// <value> |
358 | /// List used in construction of data blocks for an object update packet. This is to stop us having to | 330 | /// List used in construction of data blocks for an object update packet. This is to stop us having to |
@@ -463,9 +435,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP | |||
463 | 435 | ||
464 | m_scene = scene; | 436 | m_scene = scene; |
465 | 437 | ||
466 | m_avatarTerseUpdates = new PriorityQueue<double, ImprovedTerseObjectUpdatePacket.ObjectDataBlock>(); | 438 | m_entityUpdates = new PriorityQueue<double, EntityUpdate>(m_scene.Entities.Count); |
467 | m_primTerseUpdates = new PriorityQueue<double, ImprovedTerseObjectUpdatePacket.ObjectDataBlock>(); | ||
468 | m_primFullUpdates = new PriorityQueue<double, ObjectUpdatePacket.ObjectDataBlock>(m_scene.Entities.Count); | ||
469 | m_fullUpdateDataBlocksBuilder = new List<ObjectUpdatePacket.ObjectDataBlock>(); | 439 | m_fullUpdateDataBlocksBuilder = new List<ObjectUpdatePacket.ObjectDataBlock>(); |
470 | m_killRecord = new HashSet<uint>(); | 440 | m_killRecord = new HashSet<uint>(); |
471 | 441 | ||
@@ -1519,7 +1489,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP | |||
1519 | kill.Header.Reliable = true; | 1489 | kill.Header.Reliable = true; |
1520 | kill.Header.Zerocoded = true; | 1490 | kill.Header.Zerocoded = true; |
1521 | 1491 | ||
1522 | lock (m_primFullUpdates.SyncRoot) | 1492 | lock (m_entityUpdates.SyncRoot) |
1523 | { | 1493 | { |
1524 | m_killRecord.Add(localID); | 1494 | m_killRecord.Add(localID); |
1525 | OutPacket(kill, ThrottleOutPacketType.State); | 1495 | OutPacket(kill, ThrottleOutPacketType.State); |
@@ -3419,71 +3389,24 @@ namespace OpenSim.Region.ClientStack.LindenUDP | |||
3419 | /// <summary> | 3389 | /// <summary> |
3420 | /// Send an ObjectUpdate packet with information about an avatar | 3390 | /// Send an ObjectUpdate packet with information about an avatar |
3421 | /// </summary> | 3391 | /// </summary> |
3422 | public void SendAvatarData(SendAvatarData data) | 3392 | public void SendAvatarDataImmediate(ISceneEntity avatar) |
3423 | { | 3393 | { |
3394 | ScenePresence presence = avatar as ScenePresence; | ||
3395 | if (presence == null) | ||
3396 | return; | ||
3397 | |||
3424 | ObjectUpdatePacket objupdate = (ObjectUpdatePacket)PacketPool.Instance.GetPacket(PacketType.ObjectUpdate); | 3398 | ObjectUpdatePacket objupdate = (ObjectUpdatePacket)PacketPool.Instance.GetPacket(PacketType.ObjectUpdate); |
3425 | objupdate.Header.Zerocoded = true; | 3399 | objupdate.Header.Zerocoded = true; |
3426 | 3400 | ||
3427 | objupdate.RegionData.RegionHandle = data.RegionHandle; | 3401 | objupdate.RegionData.RegionHandle = presence.RegionHandle; |
3428 | objupdate.RegionData.TimeDilation = ushort.MaxValue; | 3402 | objupdate.RegionData.TimeDilation = ushort.MaxValue; |
3429 | 3403 | ||
3430 | objupdate.ObjectData = new ObjectUpdatePacket.ObjectDataBlock[1]; | 3404 | objupdate.ObjectData = new ObjectUpdatePacket.ObjectDataBlock[1]; |
3431 | objupdate.ObjectData[0] = CreateAvatarUpdateBlock(data); | 3405 | objupdate.ObjectData[0] = CreateAvatarUpdateBlock(presence); |
3432 | 3406 | ||
3433 | OutPacket(objupdate, ThrottleOutPacketType.Task); | 3407 | OutPacket(objupdate, ThrottleOutPacketType.Task); |
3434 | } | 3408 | } |
3435 | 3409 | ||
3436 | /// <summary> | ||
3437 | /// Send a terse positional/rotation/velocity update about an avatar | ||
3438 | /// to the client. This avatar can be that of the client itself. | ||
3439 | /// </summary> | ||
3440 | public virtual void SendAvatarTerseUpdate(SendAvatarTerseData data) | ||
3441 | { | ||
3442 | if (data.Priority == double.NaN) | ||
3443 | { | ||
3444 | m_log.Error("[LLClientView] SendAvatarTerseUpdate received a NaN priority, dropping update"); | ||
3445 | return; | ||
3446 | } | ||
3447 | |||
3448 | Quaternion rotation = data.Rotation; | ||
3449 | if (rotation.W == 0.0f && rotation.X == 0.0f && rotation.Y == 0.0f && rotation.Z == 0.0f) | ||
3450 | rotation = Quaternion.Identity; | ||
3451 | |||
3452 | ImprovedTerseObjectUpdatePacket.ObjectDataBlock terseBlock = CreateImprovedTerseBlock(data); | ||
3453 | |||
3454 | lock (m_avatarTerseUpdates.SyncRoot) | ||
3455 | m_avatarTerseUpdates.Enqueue(data.Priority, terseBlock, data.LocalID); | ||
3456 | |||
3457 | // If we received an update about our own avatar, process the avatar update priority queue immediately | ||
3458 | if (data.AgentID == m_agentId) | ||
3459 | ProcessAvatarTerseUpdates(); | ||
3460 | } | ||
3461 | |||
3462 | protected void ProcessAvatarTerseUpdates() | ||
3463 | { | ||
3464 | ImprovedTerseObjectUpdatePacket terse = (ImprovedTerseObjectUpdatePacket)PacketPool.Instance.GetPacket(PacketType.ImprovedTerseObjectUpdate); | ||
3465 | terse.Header.Reliable = false; | ||
3466 | terse.Header.Zerocoded = true; | ||
3467 | |||
3468 | //terse.RegionData = new ImprovedTerseObjectUpdatePacket.RegionDataBlock(); | ||
3469 | terse.RegionData.RegionHandle = Scene.RegionInfo.RegionHandle; | ||
3470 | terse.RegionData.TimeDilation = (ushort)(Scene.TimeDilation * ushort.MaxValue); | ||
3471 | |||
3472 | lock (m_avatarTerseUpdates.SyncRoot) | ||
3473 | { | ||
3474 | int count = Math.Min(m_avatarTerseUpdates.Count, m_udpServer.AvatarTerseUpdatesPerPacket); | ||
3475 | if (count == 0) | ||
3476 | return; | ||
3477 | |||
3478 | terse.ObjectData = new ImprovedTerseObjectUpdatePacket.ObjectDataBlock[count]; | ||
3479 | for (int i = 0; i < count; i++) | ||
3480 | terse.ObjectData[i] = m_avatarTerseUpdates.Dequeue(); | ||
3481 | } | ||
3482 | |||
3483 | // HACK: Using the task category until the tiered reprioritization code is in | ||
3484 | OutPacket(terse, ThrottleOutPacketType.Task); | ||
3485 | } | ||
3486 | |||
3487 | public void SendCoarseLocationUpdate(List<UUID> users, List<Vector3> CoarseLocations) | 3410 | public void SendCoarseLocationUpdate(List<UUID> users, List<Vector3> CoarseLocations) |
3488 | { | 3411 | { |
3489 | if (!IsActive) return; // We don't need to update inactive clients. | 3412 | if (!IsActive) return; // We don't need to update inactive clients. |
@@ -3528,172 +3451,188 @@ namespace OpenSim.Region.ClientStack.LindenUDP | |||
3528 | 3451 | ||
3529 | #region Primitive Packet/Data Sending Methods | 3452 | #region Primitive Packet/Data Sending Methods |
3530 | 3453 | ||
3531 | public void SendPrimitiveToClient(SendPrimitiveData data) | 3454 | /// <summary> |
3455 | /// Generate one of the object update packets based on PrimUpdateFlags | ||
3456 | /// and broadcast the packet to clients | ||
3457 | /// </summary> | ||
3458 | public void SendPrimUpdate(ISceneEntity entity, PrimUpdateFlags updateFlags) | ||
3532 | { | 3459 | { |
3533 | // string text = data.text; | 3460 | double priority; |
3534 | // if (text.IndexOf("\n") >= 0) | ||
3535 | // text = text.Remove(text.IndexOf("\n")); | ||
3536 | // m_log.DebugFormat( | ||
3537 | // "[CLIENT]: Placing request to send full info about prim {0} text {1} to client {2}", | ||
3538 | // data.localID, text, Name); | ||
3539 | |||
3540 | if (data.priority == double.NaN) | ||
3541 | { | ||
3542 | m_log.Error("[LLClientView] SendPrimitiveToClient received a NaN priority, dropping update"); | ||
3543 | return; | ||
3544 | } | ||
3545 | |||
3546 | Quaternion rotation = data.rotation; | ||
3547 | if (rotation.W == 0.0f && rotation.X == 0.0f && rotation.Y == 0.0f && rotation.Z == 0.0f) | ||
3548 | rotation = Quaternion.Identity; | ||
3549 | |||
3550 | if (data.AttachPoint > 30 && data.ownerID != AgentId) // Someone else's HUD | ||
3551 | return; | ||
3552 | if (data.primShape.State != 0 && data.parentID == 0 && data.primShape.PCode == 9) | ||
3553 | return; | ||
3554 | 3461 | ||
3555 | ObjectUpdatePacket.ObjectDataBlock objectData = CreatePrimUpdateBlock(data); | 3462 | if (entity is SceneObjectPart) |
3463 | priority = ((SceneObjectPart)entity).ParentGroup.GetUpdatePriority(this); | ||
3464 | else if (entity is ScenePresence) | ||
3465 | priority = ((ScenePresence)entity).GetUpdatePriority(this); | ||
3466 | else | ||
3467 | priority = 0.0d; | ||
3556 | 3468 | ||
3557 | lock (m_primFullUpdates.SyncRoot) | 3469 | lock (m_entityUpdates.SyncRoot) |
3558 | m_primFullUpdates.Enqueue(data.priority, objectData, data.localID); | 3470 | m_entityUpdates.Enqueue(priority, new EntityUpdate(entity, updateFlags), entity.LocalId); |
3559 | } | 3471 | } |
3560 | 3472 | ||
3561 | void ProcessPrimFullUpdates() | 3473 | private void ProcessEntityUpdates(int maxUpdates) |
3562 | { | 3474 | { |
3563 | ObjectUpdatePacket outPacket = (ObjectUpdatePacket)PacketPool.Instance.GetPacket(PacketType.ObjectUpdate); | 3475 | Lazy<List<ObjectUpdatePacket.ObjectDataBlock>> objectUpdateBlocks = new Lazy<List<ObjectUpdatePacket.ObjectDataBlock>>(); |
3564 | outPacket.Header.Zerocoded = true; | 3476 | Lazy<List<ObjectUpdateCompressedPacket.ObjectDataBlock>> compressedUpdateBlocks = new Lazy<List<ObjectUpdateCompressedPacket.ObjectDataBlock>>(); |
3477 | Lazy<List<ImprovedTerseObjectUpdatePacket.ObjectDataBlock>> terseUpdateBlocks = new Lazy<List<ImprovedTerseObjectUpdatePacket.ObjectDataBlock>>(); | ||
3565 | 3478 | ||
3566 | outPacket.RegionData.RegionHandle = Scene.RegionInfo.RegionHandle; | 3479 | int updatesThisCall = 0; |
3567 | outPacket.RegionData.TimeDilation = (ushort)(Scene.TimeDilation * ushort.MaxValue); | ||
3568 | 3480 | ||
3569 | lock (m_primFullUpdates.SyncRoot) | 3481 | lock (m_entityUpdates.SyncRoot) |
3570 | { | 3482 | { |
3571 | int count = Math.Min(m_primFullUpdates.Count, m_udpServer.PrimFullUpdatesPerPacket); | 3483 | EntityUpdate update; |
3572 | if (count == 0) | 3484 | while (m_entityUpdates.TryDequeue(out update)) |
3573 | return; | ||
3574 | |||
3575 | m_fullUpdateDataBlocksBuilder.Clear(); | ||
3576 | |||
3577 | for (int i = 0; i < count; i++) | ||
3578 | { | 3485 | { |
3579 | ObjectUpdatePacket.ObjectDataBlock block = m_primFullUpdates.Dequeue(); | 3486 | #region UpdateFlags to packet type conversion |
3487 | |||
3488 | PrimUpdateFlags updateFlags = update.Flags; | ||
3580 | 3489 | ||
3581 | if (!m_killRecord.Contains(block.ID)) | 3490 | bool canUseCompressed = true; |
3491 | bool canUseImproved = true; | ||
3492 | |||
3493 | // Compressed object updates only make sense for LL primitives | ||
3494 | if (!(update.Entity is SceneObjectPart)) | ||
3495 | canUseCompressed = false; | ||
3496 | |||
3497 | if (updateFlags.HasFlag(PrimUpdateFlags.FullUpdate)) | ||
3582 | { | 3498 | { |
3583 | m_fullUpdateDataBlocksBuilder.Add(block); | 3499 | canUseCompressed = false; |
3584 | 3500 | canUseImproved = false; | |
3585 | // string text = Util.FieldToString(outPacket.ObjectData[i].Text); | 3501 | } |
3586 | // if (text.IndexOf("\n") >= 0) | 3502 | else |
3587 | // text = text.Remove(text.IndexOf("\n")); | 3503 | { |
3588 | // m_log.DebugFormat( | 3504 | if (updateFlags.HasFlag(PrimUpdateFlags.Velocity) || |
3589 | // "[CLIENT]: Sending full info about prim {0} text {1} to client {2}", | 3505 | updateFlags.HasFlag(PrimUpdateFlags.Acceleration) || |
3590 | // outPacket.ObjectData[i].ID, text, Name); | 3506 | updateFlags.HasFlag(PrimUpdateFlags.CollisionPlane) || |
3507 | updateFlags.HasFlag(PrimUpdateFlags.Joint)) | ||
3508 | { | ||
3509 | canUseCompressed = false; | ||
3510 | } | ||
3511 | |||
3512 | if (updateFlags.HasFlag(PrimUpdateFlags.PrimFlags) || | ||
3513 | updateFlags.HasFlag(PrimUpdateFlags.ParentID) || | ||
3514 | updateFlags.HasFlag(PrimUpdateFlags.Scale) || | ||
3515 | updateFlags.HasFlag(PrimUpdateFlags.PrimData) || | ||
3516 | updateFlags.HasFlag(PrimUpdateFlags.Text) || | ||
3517 | updateFlags.HasFlag(PrimUpdateFlags.NameValue) || | ||
3518 | updateFlags.HasFlag(PrimUpdateFlags.ExtraData) || | ||
3519 | updateFlags.HasFlag(PrimUpdateFlags.TextureAnim) || | ||
3520 | updateFlags.HasFlag(PrimUpdateFlags.Sound) || | ||
3521 | updateFlags.HasFlag(PrimUpdateFlags.Particles) || | ||
3522 | updateFlags.HasFlag(PrimUpdateFlags.Material) || | ||
3523 | updateFlags.HasFlag(PrimUpdateFlags.ClickAction) || | ||
3524 | updateFlags.HasFlag(PrimUpdateFlags.MediaURL) || | ||
3525 | updateFlags.HasFlag(PrimUpdateFlags.Joint)) | ||
3526 | { | ||
3527 | canUseImproved = false; | ||
3528 | } | ||
3529 | } | ||
3530 | |||
3531 | #endregion UpdateFlags to packet type conversion | ||
3532 | |||
3533 | #region Block Construction | ||
3534 | |||
3535 | // TODO: Remove this once we can build compressed updates | ||
3536 | canUseCompressed = false; | ||
3537 | |||
3538 | if (!canUseImproved && !canUseCompressed) | ||
3539 | { | ||
3540 | if (update.Entity is ScenePresence) | ||
3541 | objectUpdateBlocks.Value.Add(CreateAvatarUpdateBlock((ScenePresence)update.Entity)); | ||
3542 | else | ||
3543 | objectUpdateBlocks.Value.Add(CreatePrimUpdateBlock((SceneObjectPart)update.Entity, this.m_agentId)); | ||
3591 | } | 3544 | } |
3592 | // else | 3545 | else if (!canUseImproved) |
3593 | // { | 3546 | { |
3594 | // m_log.WarnFormat( | 3547 | compressedUpdateBlocks.Value.Add(CreateCompressedUpdateBlock((SceneObjectPart)update.Entity, updateFlags)); |
3595 | // "[CLIENT]: Preventing full update for {0} after kill to {1}", block.ID, Name); | 3548 | } |
3596 | // } | 3549 | else |
3550 | { | ||
3551 | terseUpdateBlocks.Value.Add(CreateImprovedTerseBlock(update.Entity, updateFlags.HasFlag(PrimUpdateFlags.Textures))); | ||
3552 | } | ||
3553 | |||
3554 | #endregion Block Construction | ||
3555 | |||
3556 | ++updatesThisCall; | ||
3557 | if (maxUpdates > 0 && updatesThisCall >= maxUpdates) | ||
3558 | break; | ||
3597 | } | 3559 | } |
3560 | } | ||
3598 | 3561 | ||
3599 | outPacket.ObjectData = m_fullUpdateDataBlocksBuilder.ToArray(); | 3562 | #region Packet Sending |
3600 | |||
3601 | OutPacket(outPacket, ThrottleOutPacketType.State); | ||
3602 | } | ||
3603 | } | ||
3604 | 3563 | ||
3605 | public void SendPrimTerseUpdate(SendPrimitiveTerseData data) | 3564 | const float TIME_DILATION = 1.0f; |
3606 | { | 3565 | ushort timeDilation = Utils.FloatToUInt16(TIME_DILATION, 0.0f, 1.0f); |
3607 | if (data.Priority == double.NaN) | 3566 | |
3567 | if (objectUpdateBlocks.IsValueCreated) | ||
3608 | { | 3568 | { |
3609 | m_log.Error("[LLClientView] SendPrimTerseUpdate received a NaN priority, dropping update"); | 3569 | List<ObjectUpdatePacket.ObjectDataBlock> blocks = objectUpdateBlocks.Value; |
3610 | return; | ||
3611 | } | ||
3612 | 3570 | ||
3613 | Quaternion rotation = data.Rotation; | 3571 | ObjectUpdatePacket packet = (ObjectUpdatePacket)PacketPool.Instance.GetPacket(PacketType.ObjectUpdate); |
3614 | if (rotation.W == 0.0f && rotation.X == 0.0f && rotation.Y == 0.0f && rotation.Z == 0.0f) | 3572 | packet.RegionData.RegionHandle = m_scene.RegionInfo.RegionHandle; |
3615 | rotation = Quaternion.Identity; | 3573 | packet.RegionData.TimeDilation = timeDilation; |
3574 | packet.ObjectData = new ObjectUpdatePacket.ObjectDataBlock[blocks.Count]; | ||
3616 | 3575 | ||
3617 | if (data.AttachPoint > 30 && data.OwnerID != AgentId) // Someone else's HUD | 3576 | for (int i = 0; i < blocks.Count; i++) |
3618 | return; | 3577 | packet.ObjectData[i] = blocks[i]; |
3578 | |||
3579 | OutPacket(packet, ThrottleOutPacketType.Task, true); | ||
3580 | } | ||
3619 | 3581 | ||
3620 | ImprovedTerseObjectUpdatePacket.ObjectDataBlock objectData = CreateImprovedTerseBlock(data); | 3582 | if (compressedUpdateBlocks.IsValueCreated) |
3583 | { | ||
3584 | List<ObjectUpdateCompressedPacket.ObjectDataBlock> blocks = compressedUpdateBlocks.Value; | ||
3621 | 3585 | ||
3622 | lock (m_primTerseUpdates.SyncRoot) | 3586 | ObjectUpdateCompressedPacket packet = (ObjectUpdateCompressedPacket)PacketPool.Instance.GetPacket(PacketType.ObjectUpdateCompressed); |
3623 | m_primTerseUpdates.Enqueue(data.Priority, objectData, data.LocalID); | 3587 | packet.RegionData.RegionHandle = m_scene.RegionInfo.RegionHandle; |
3624 | } | 3588 | packet.RegionData.TimeDilation = timeDilation; |
3589 | packet.ObjectData = new ObjectUpdateCompressedPacket.ObjectDataBlock[blocks.Count]; | ||
3625 | 3590 | ||
3626 | void ProcessPrimTerseUpdates() | 3591 | for (int i = 0; i < blocks.Count; i++) |
3627 | { | 3592 | packet.ObjectData[i] = blocks[i]; |
3628 | ImprovedTerseObjectUpdatePacket outPacket = (ImprovedTerseObjectUpdatePacket)PacketPool.Instance.GetPacket(PacketType.ImprovedTerseObjectUpdate); | ||
3629 | outPacket.Header.Reliable = false; | ||
3630 | outPacket.Header.Zerocoded = true; | ||
3631 | 3593 | ||
3632 | outPacket.RegionData.RegionHandle = Scene.RegionInfo.RegionHandle; | 3594 | OutPacket(packet, ThrottleOutPacketType.Task, true); |
3633 | outPacket.RegionData.TimeDilation = (ushort)(Scene.TimeDilation * ushort.MaxValue); | 3595 | } |
3634 | 3596 | ||
3635 | lock (m_primTerseUpdates.SyncRoot) | 3597 | if (terseUpdateBlocks.IsValueCreated) |
3636 | { | 3598 | { |
3637 | int count = Math.Min(m_primTerseUpdates.Count, m_udpServer.PrimTerseUpdatesPerPacket); | 3599 | List<ImprovedTerseObjectUpdatePacket.ObjectDataBlock> blocks = terseUpdateBlocks.Value; |
3638 | if (count == 0) | 3600 | |
3639 | return; | 3601 | ImprovedTerseObjectUpdatePacket packet = new ImprovedTerseObjectUpdatePacket(); |
3602 | packet.RegionData.RegionHandle = m_scene.RegionInfo.RegionHandle; | ||
3603 | packet.RegionData.TimeDilation = timeDilation; | ||
3604 | packet.ObjectData = new ImprovedTerseObjectUpdatePacket.ObjectDataBlock[blocks.Count]; | ||
3640 | 3605 | ||
3641 | outPacket.ObjectData = new ImprovedTerseObjectUpdatePacket.ObjectDataBlock[count]; | 3606 | for (int i = 0; i < blocks.Count; i++) |
3642 | for (int i = 0; i < count; i++) | 3607 | packet.ObjectData[i] = blocks[i]; |
3643 | outPacket.ObjectData[i] = m_primTerseUpdates.Dequeue(); | 3608 | |
3609 | OutPacket(packet, ThrottleOutPacketType.Task, true); | ||
3644 | } | 3610 | } |
3645 | 3611 | ||
3646 | OutPacket(outPacket, ThrottleOutPacketType.State); | 3612 | #endregion Packet Sending |
3647 | } | 3613 | } |
3648 | 3614 | ||
3649 | public void ReprioritizeUpdates(StateUpdateTypes type, UpdatePriorityHandler handler) | 3615 | public void ReprioritizeUpdates(UpdatePriorityHandler handler) |
3650 | { | 3616 | { |
3651 | PriorityQueue<double, ImprovedTerseObjectUpdatePacket.ObjectDataBlock>.UpdatePriorityHandler terse_update_priority_handler = | 3617 | //m_log.Debug("[CLIENT]: Reprioritizing prim updates for " + m_firstName + " " + m_lastName); |
3652 | delegate(ref double priority, uint local_id) | 3618 | |
3653 | { | 3619 | PriorityQueue<double, EntityUpdate>.UpdatePriorityHandler update_priority_handler = |
3654 | priority = handler(new UpdatePriorityData(priority, local_id)); | ||
3655 | return priority != double.NaN; | ||
3656 | }; | ||
3657 | PriorityQueue<double, ObjectUpdatePacket.ObjectDataBlock>.UpdatePriorityHandler update_priority_handler = | ||
3658 | delegate(ref double priority, uint local_id) | 3620 | delegate(ref double priority, uint local_id) |
3659 | { | 3621 | { |
3660 | priority = handler(new UpdatePriorityData(priority, local_id)); | 3622 | priority = handler(new UpdatePriorityData(priority, local_id)); |
3661 | return priority != double.NaN; | 3623 | return priority != double.NaN; |
3662 | }; | 3624 | }; |
3663 | 3625 | ||
3664 | if ((type & StateUpdateTypes.AvatarTerse) != 0) | 3626 | lock (m_entityUpdates.SyncRoot) |
3665 | { | 3627 | m_entityUpdates.Reprioritize(update_priority_handler); |
3666 | lock (m_avatarTerseUpdates.SyncRoot) | ||
3667 | m_avatarTerseUpdates.Reprioritize(terse_update_priority_handler); | ||
3668 | } | ||
3669 | |||
3670 | if ((type & StateUpdateTypes.PrimitiveFull) != 0) | ||
3671 | { | ||
3672 | lock (m_primFullUpdates.SyncRoot) | ||
3673 | m_primFullUpdates.Reprioritize(update_priority_handler); | ||
3674 | } | ||
3675 | |||
3676 | if ((type & StateUpdateTypes.PrimitiveTerse) != 0) | ||
3677 | { | ||
3678 | lock (m_primTerseUpdates.SyncRoot) | ||
3679 | m_primTerseUpdates.Reprioritize(terse_update_priority_handler); | ||
3680 | } | ||
3681 | } | 3628 | } |
3682 | 3629 | ||
3683 | public void FlushPrimUpdates() | 3630 | public void FlushPrimUpdates() |
3684 | { | 3631 | { |
3685 | while (m_primFullUpdates.Count > 0) | 3632 | m_log.Debug("[CLIENT]: Flushing prim updates to " + m_firstName + " " + m_lastName); |
3686 | { | 3633 | |
3687 | ProcessPrimFullUpdates(); | 3634 | while (m_entityUpdates.Count > 0) |
3688 | } | 3635 | ProcessEntityUpdates(-1); |
3689 | while (m_primTerseUpdates.Count > 0) | ||
3690 | { | ||
3691 | ProcessPrimTerseUpdates(); | ||
3692 | } | ||
3693 | while (m_avatarTerseUpdates.Count > 0) | ||
3694 | { | ||
3695 | ProcessAvatarTerseUpdates(); | ||
3696 | } | ||
3697 | } | 3636 | } |
3698 | 3637 | ||
3699 | #endregion Primitive Packet/Data Sending Methods | 3638 | #endregion Primitive Packet/Data Sending Methods |
@@ -3726,26 +3665,8 @@ namespace OpenSim.Region.ClientStack.LindenUDP | |||
3726 | { | 3665 | { |
3727 | if ((categories & ThrottleOutPacketTypeFlags.Task) != 0) | 3666 | if ((categories & ThrottleOutPacketTypeFlags.Task) != 0) |
3728 | { | 3667 | { |
3729 | lock (m_avatarTerseUpdates.SyncRoot) | 3668 | if (m_entityUpdates.Count > 0) |
3730 | { | 3669 | ProcessEntityUpdates(m_udpServer.PrimUpdatesPerCallback); |
3731 | if (m_avatarTerseUpdates.Count > 0) | ||
3732 | ProcessAvatarTerseUpdates(); | ||
3733 | } | ||
3734 | } | ||
3735 | |||
3736 | if ((categories & ThrottleOutPacketTypeFlags.State) != 0) | ||
3737 | { | ||
3738 | lock (m_primFullUpdates.SyncRoot) | ||
3739 | { | ||
3740 | if (m_primFullUpdates.Count > 0) | ||
3741 | ProcessPrimFullUpdates(); | ||
3742 | } | ||
3743 | |||
3744 | lock (m_primTerseUpdates.SyncRoot) | ||
3745 | { | ||
3746 | if (m_primTerseUpdates.Count > 0) | ||
3747 | ProcessPrimTerseUpdates(); | ||
3748 | } | ||
3749 | } | 3670 | } |
3750 | 3671 | ||
3751 | if ((categories & ThrottleOutPacketTypeFlags.Texture) != 0) | 3672 | if ((categories & ThrottleOutPacketTypeFlags.Texture) != 0) |
@@ -4403,22 +4324,51 @@ namespace OpenSim.Region.ClientStack.LindenUDP | |||
4403 | 4324 | ||
4404 | #region Helper Methods | 4325 | #region Helper Methods |
4405 | 4326 | ||
4406 | protected ImprovedTerseObjectUpdatePacket.ObjectDataBlock CreateImprovedTerseBlock(SendAvatarTerseData data) | 4327 | protected ImprovedTerseObjectUpdatePacket.ObjectDataBlock CreateImprovedTerseBlock(ISceneEntity entity, bool sendTexture) |
4407 | { | 4328 | { |
4408 | return CreateImprovedTerseBlock(true, data.LocalID, 0, data.CollisionPlane, data.Position, data.Velocity, | 4329 | #region ScenePresence/SOP Handling |
4409 | data.Acceleration, data.Rotation, Vector3.Zero, data.TextureEntry); | ||
4410 | } | ||
4411 | 4330 | ||
4412 | protected ImprovedTerseObjectUpdatePacket.ObjectDataBlock CreateImprovedTerseBlock(SendPrimitiveTerseData data) | 4331 | bool avatar = (entity is ScenePresence); |
4413 | { | 4332 | uint localID = entity.LocalId; |
4414 | return CreateImprovedTerseBlock(false, data.LocalID, data.AttachPoint, Vector4.Zero, data.Position, data.Velocity, | 4333 | uint attachPoint; |
4415 | data.Acceleration, data.Rotation, data.AngularVelocity, data.TextureEntry); | 4334 | Vector4 collisionPlane; |
4416 | } | 4335 | Vector3 position, velocity, acceleration, angularVelocity; |
4336 | Quaternion rotation; | ||
4337 | byte[] textureEntry; | ||
4338 | |||
4339 | if (entity is ScenePresence) | ||
4340 | { | ||
4341 | ScenePresence presence = (ScenePresence)entity; | ||
4342 | |||
4343 | attachPoint = 0; | ||
4344 | collisionPlane = presence.CollisionPlane; | ||
4345 | position = presence.OffsetPosition; | ||
4346 | velocity = presence.Velocity; | ||
4347 | acceleration = Vector3.Zero; | ||
4348 | angularVelocity = Vector3.Zero; | ||
4349 | rotation = presence.Rotation; | ||
4350 | |||
4351 | if (sendTexture) | ||
4352 | textureEntry = presence.Appearance.Texture.GetBytes(); | ||
4353 | else | ||
4354 | textureEntry = null; | ||
4355 | } | ||
4356 | else | ||
4357 | { | ||
4358 | SceneObjectPart part = (SceneObjectPart)entity; | ||
4359 | |||
4360 | attachPoint = part.AttachmentPoint; | ||
4361 | collisionPlane = Vector4.Zero; | ||
4362 | position = part.RelativePosition; | ||
4363 | velocity = part.Velocity; | ||
4364 | acceleration = part.Acceleration; | ||
4365 | angularVelocity = part.AngularVelocity; | ||
4366 | rotation = part.RotationOffset; | ||
4367 | textureEntry = part.Shape.TextureEntry; | ||
4368 | } | ||
4369 | |||
4370 | #endregion ScenePresence/SOP Handling | ||
4417 | 4371 | ||
4418 | protected ImprovedTerseObjectUpdatePacket.ObjectDataBlock CreateImprovedTerseBlock(bool avatar, uint localID, int attachPoint, | ||
4419 | Vector4 collisionPlane, Vector3 position, Vector3 velocity, Vector3 acceleration, Quaternion rotation, | ||
4420 | Vector3 angularVelocity, byte[] textureEntry) | ||
4421 | { | ||
4422 | int pos = 0; | 4372 | int pos = 0; |
4423 | byte[] data = new byte[(avatar ? 60 : 44)]; | 4373 | byte[] data = new byte[(avatar ? 60 : 44)]; |
4424 | 4374 | ||
@@ -4490,12 +4440,12 @@ namespace OpenSim.Region.ClientStack.LindenUDP | |||
4490 | return block; | 4440 | return block; |
4491 | } | 4441 | } |
4492 | 4442 | ||
4493 | protected ObjectUpdatePacket.ObjectDataBlock CreateAvatarUpdateBlock(SendAvatarData data) | 4443 | protected ObjectUpdatePacket.ObjectDataBlock CreateAvatarUpdateBlock(ScenePresence data) |
4494 | { | 4444 | { |
4495 | byte[] objectData = new byte[76]; | 4445 | byte[] objectData = new byte[76]; |
4496 | 4446 | ||
4497 | Vector4.UnitW.ToBytes(objectData, 0); // TODO: Collision plane support | 4447 | data.CollisionPlane.ToBytes(objectData, 0); |
4498 | data.Position.ToBytes(objectData, 16); | 4448 | data.OffsetPosition.ToBytes(objectData, 16); |
4499 | //data.Velocity.ToBytes(objectData, 28); | 4449 | //data.Velocity.ToBytes(objectData, 28); |
4500 | //data.Acceleration.ToBytes(objectData, 40); | 4450 | //data.Acceleration.ToBytes(objectData, 40); |
4501 | data.Rotation.ToBytes(objectData, 52); | 4451 | data.Rotation.ToBytes(objectData, 52); |
@@ -4505,12 +4455,12 @@ namespace OpenSim.Region.ClientStack.LindenUDP | |||
4505 | 4455 | ||
4506 | update.Data = Utils.EmptyBytes; | 4456 | update.Data = Utils.EmptyBytes; |
4507 | update.ExtraParams = new byte[1]; | 4457 | update.ExtraParams = new byte[1]; |
4508 | update.FullID = data.AvatarID; | 4458 | update.FullID = data.UUID; |
4509 | update.ID = data.AvatarLocalID; | 4459 | update.ID = data.LocalId; |
4510 | update.Material = (byte)Material.Flesh; | 4460 | update.Material = (byte)Material.Flesh; |
4511 | update.MediaURL = Utils.EmptyBytes; | 4461 | update.MediaURL = Utils.EmptyBytes; |
4512 | update.NameValue = Utils.StringToBytes("FirstName STRING RW SV " + data.FirstName + "\nLastName STRING RW SV " + | 4462 | update.NameValue = Utils.StringToBytes("FirstName STRING RW SV " + data.Firstname + "\nLastName STRING RW SV " + |
4513 | data.LastName + "\nTitle STRING RW SV " + data.GroupTitle); | 4463 | data.Lastname + "\nTitle STRING RW SV " + data.Grouptitle); |
4514 | update.ObjectData = objectData; | 4464 | update.ObjectData = objectData; |
4515 | update.ParentID = data.ParentID; | 4465 | update.ParentID = data.ParentID; |
4516 | update.PathCurve = 16; | 4466 | update.PathCurve = 16; |
@@ -4519,102 +4469,116 @@ namespace OpenSim.Region.ClientStack.LindenUDP | |||
4519 | update.PCode = (byte)PCode.Avatar; | 4469 | update.PCode = (byte)PCode.Avatar; |
4520 | update.ProfileCurve = 1; | 4470 | update.ProfileCurve = 1; |
4521 | update.PSBlock = Utils.EmptyBytes; | 4471 | update.PSBlock = Utils.EmptyBytes; |
4522 | update.Scale = new Vector3(0.45f,0.6f,1.9f); | 4472 | update.Scale = new Vector3(0.45f, 0.6f, 1.9f); |
4523 | update.Text = Utils.EmptyBytes; | 4473 | update.Text = Utils.EmptyBytes; |
4524 | update.TextColor = new byte[4]; | 4474 | update.TextColor = new byte[4]; |
4525 | update.TextureAnim = Utils.EmptyBytes; | 4475 | update.TextureAnim = Utils.EmptyBytes; |
4526 | update.TextureEntry = data.TextureEntry ?? Utils.EmptyBytes; | 4476 | update.TextureEntry = (data.Appearance.Texture != null) ? data.Appearance.Texture.GetBytes() : Utils.EmptyBytes; |
4527 | update.UpdateFlags = (uint)(PrimFlags.Physics | PrimFlags.ObjectModify | PrimFlags.ObjectCopy | PrimFlags.ObjectAnyOwner | PrimFlags.ObjectYouOwner | PrimFlags.ObjectMove | PrimFlags.InventoryEmpty | PrimFlags.ObjectTransfer | PrimFlags.ObjectOwnerModify);//61 + (9 << 8) + (130 << 16) + (16 << 24); // TODO: Replace these numbers with PrimFlags | 4477 | update.UpdateFlags = (uint)( |
4478 | PrimFlags.Physics | PrimFlags.ObjectModify | PrimFlags.ObjectCopy | PrimFlags.ObjectAnyOwner | | ||
4479 | PrimFlags.ObjectYouOwner | PrimFlags.ObjectMove | PrimFlags.InventoryEmpty | PrimFlags.ObjectTransfer | | ||
4480 | PrimFlags.ObjectOwnerModify); | ||
4528 | 4481 | ||
4529 | return update; | 4482 | return update; |
4530 | } | 4483 | } |
4531 | 4484 | ||
4532 | protected ObjectUpdatePacket.ObjectDataBlock CreatePrimUpdateBlock(SendPrimitiveData data) | 4485 | protected ObjectUpdatePacket.ObjectDataBlock CreatePrimUpdateBlock(SceneObjectPart data, UUID recipientID) |
4533 | { | 4486 | { |
4534 | byte[] objectData = new byte[60]; | 4487 | byte[] objectData = new byte[60]; |
4535 | data.pos.ToBytes(objectData, 0); | 4488 | data.RelativePosition.ToBytes(objectData, 0); |
4536 | data.vel.ToBytes(objectData, 12); | 4489 | data.Velocity.ToBytes(objectData, 12); |
4537 | data.acc.ToBytes(objectData, 24); | 4490 | data.Acceleration.ToBytes(objectData, 24); |
4538 | data.rotation.ToBytes(objectData, 36); | 4491 | data.RotationOffset.ToBytes(objectData, 36); |
4539 | data.rvel.ToBytes(objectData, 48); | 4492 | data.AngularVelocity.ToBytes(objectData, 48); |
4540 | 4493 | ||
4541 | ObjectUpdatePacket.ObjectDataBlock update = new ObjectUpdatePacket.ObjectDataBlock(); | 4494 | ObjectUpdatePacket.ObjectDataBlock update = new ObjectUpdatePacket.ObjectDataBlock(); |
4542 | update.ClickAction = (byte)data.clickAction; | 4495 | update.ClickAction = (byte)data.ClickAction; |
4543 | update.CRC = 0; | 4496 | update.CRC = 0; |
4544 | update.ExtraParams = data.primShape.ExtraParams ?? Utils.EmptyBytes; | 4497 | update.ExtraParams = data.Shape.ExtraParams ?? Utils.EmptyBytes; |
4545 | update.FullID = data.objectID; | 4498 | update.FullID = data.UUID; |
4546 | update.ID = data.localID; | 4499 | update.ID = data.LocalId; |
4547 | //update.JointAxisOrAnchor = Vector3.Zero; // These are deprecated | 4500 | //update.JointAxisOrAnchor = Vector3.Zero; // These are deprecated |
4548 | //update.JointPivot = Vector3.Zero; | 4501 | //update.JointPivot = Vector3.Zero; |
4549 | //update.JointType = 0; | 4502 | //update.JointType = 0; |
4550 | update.Material = data.material; | 4503 | update.Material = data.Material; |
4551 | update.MediaURL = Utils.EmptyBytes; // FIXME: Support this in OpenSim | 4504 | update.MediaURL = Utils.EmptyBytes; // FIXME: Support this in OpenSim |
4552 | if (data.attachment) | 4505 | if (data.IsAttachment) |
4553 | { | 4506 | { |
4554 | update.NameValue = Util.StringToBytes256("AttachItemID STRING RW SV " + data.AssetId); | 4507 | update.NameValue = Util.StringToBytes256("AttachItemID STRING RW SV " + data.FromItemID); |
4555 | update.State = (byte)((data.AttachPoint % 16) * 16 + (data.AttachPoint / 16)); | 4508 | update.State = (byte)((data.AttachmentPoint % 16) * 16 + (data.AttachmentPoint / 16)); |
4556 | } | 4509 | } |
4557 | else | 4510 | else |
4558 | { | 4511 | { |
4559 | update.NameValue = Utils.EmptyBytes; | 4512 | update.NameValue = Utils.EmptyBytes; |
4560 | update.State = data.primShape.State; | 4513 | update.State = data.Shape.State; |
4561 | } | 4514 | } |
4515 | |||
4562 | update.ObjectData = objectData; | 4516 | update.ObjectData = objectData; |
4563 | update.ParentID = data.parentID; | 4517 | update.ParentID = data.ParentID; |
4564 | update.PathBegin = data.primShape.PathBegin; | 4518 | update.PathBegin = data.Shape.PathBegin; |
4565 | update.PathCurve = data.primShape.PathCurve; | 4519 | update.PathCurve = data.Shape.PathCurve; |
4566 | update.PathEnd = data.primShape.PathEnd; | 4520 | update.PathEnd = data.Shape.PathEnd; |
4567 | update.PathRadiusOffset = data.primShape.PathRadiusOffset; | 4521 | update.PathRadiusOffset = data.Shape.PathRadiusOffset; |
4568 | update.PathRevolutions = data.primShape.PathRevolutions; | 4522 | update.PathRevolutions = data.Shape.PathRevolutions; |
4569 | update.PathScaleX = data.primShape.PathScaleX; | 4523 | update.PathScaleX = data.Shape.PathScaleX; |
4570 | update.PathScaleY = data.primShape.PathScaleY; | 4524 | update.PathScaleY = data.Shape.PathScaleY; |
4571 | update.PathShearX = data.primShape.PathShearX; | 4525 | update.PathShearX = data.Shape.PathShearX; |
4572 | update.PathShearY = data.primShape.PathShearY; | 4526 | update.PathShearY = data.Shape.PathShearY; |
4573 | update.PathSkew = data.primShape.PathSkew; | 4527 | update.PathSkew = data.Shape.PathSkew; |
4574 | update.PathTaperX = data.primShape.PathTaperX; | 4528 | update.PathTaperX = data.Shape.PathTaperX; |
4575 | update.PathTaperY = data.primShape.PathTaperY; | 4529 | update.PathTaperY = data.Shape.PathTaperY; |
4576 | update.PathTwist = data.primShape.PathTwist; | 4530 | update.PathTwist = data.Shape.PathTwist; |
4577 | update.PathTwistBegin = data.primShape.PathTwistBegin; | 4531 | update.PathTwistBegin = data.Shape.PathTwistBegin; |
4578 | update.PCode = data.primShape.PCode; | 4532 | update.PCode = data.Shape.PCode; |
4579 | update.ProfileBegin = data.primShape.ProfileBegin; | 4533 | update.ProfileBegin = data.Shape.ProfileBegin; |
4580 | update.ProfileCurve = data.primShape.ProfileCurve; | 4534 | update.ProfileCurve = data.Shape.ProfileCurve; |
4581 | update.ProfileEnd = data.primShape.ProfileEnd; | 4535 | update.ProfileEnd = data.Shape.ProfileEnd; |
4582 | update.ProfileHollow = data.primShape.ProfileHollow; | 4536 | update.ProfileHollow = data.Shape.ProfileHollow; |
4583 | update.PSBlock = data.particleSystem ?? Utils.EmptyBytes; | 4537 | update.PSBlock = data.ParticleSystem ?? Utils.EmptyBytes; |
4584 | update.TextColor = data.color ?? Color4.Black.GetBytes(true); | 4538 | update.TextColor = data.GetTextColor().GetBytes(false); |
4585 | update.TextureAnim = data.textureanim ?? Utils.EmptyBytes; | 4539 | update.TextureAnim = data.TextureAnimation ?? Utils.EmptyBytes; |
4586 | update.TextureEntry = data.primShape.TextureEntry ?? Utils.EmptyBytes; | 4540 | update.TextureEntry = data.Shape.TextureEntry ?? Utils.EmptyBytes; |
4587 | update.Scale = data.primShape.Scale; | 4541 | update.Scale = data.Shape.Scale; |
4588 | update.Text = Util.StringToBytes256(data.text); | 4542 | update.Text = Util.StringToBytes256(data.Text); |
4589 | update.UpdateFlags = (uint)data.flags; | 4543 | |
4590 | 4544 | #region PrimFlags | |
4591 | if (data.SoundId != UUID.Zero) | 4545 | |
4592 | { | 4546 | PrimFlags flags = (PrimFlags)m_scene.Permissions.GenerateClientFlags(recipientID, data.UUID); |
4593 | update.Sound = data.SoundId; | 4547 | |
4594 | update.OwnerID = data.ownerID; | 4548 | // Don't send the CreateSelected flag to everyone |
4595 | update.Gain = (float)data.SoundVolume; | 4549 | flags &= ~PrimFlags.CreateSelected; |
4550 | |||
4551 | if (recipientID == data.OwnerID) | ||
4552 | { | ||
4553 | if ((data.Flags & PrimFlags.CreateSelected) != 0) | ||
4554 | { | ||
4555 | // Only send this flag once, then unset it | ||
4556 | flags |= PrimFlags.CreateSelected; | ||
4557 | data.Flags &= ~PrimFlags.CreateSelected; | ||
4558 | } | ||
4559 | } | ||
4560 | |||
4561 | update.UpdateFlags = (uint)flags; | ||
4562 | |||
4563 | #endregion PrimFlags | ||
4564 | |||
4565 | if (data.Sound != UUID.Zero) | ||
4566 | { | ||
4567 | update.Sound = data.Sound; | ||
4568 | update.OwnerID = data.OwnerID; | ||
4569 | update.Gain = (float)data.SoundGain; | ||
4596 | update.Radius = (float)data.SoundRadius; | 4570 | update.Radius = (float)data.SoundRadius; |
4597 | update.Flags = data.SoundFlags; | 4571 | update.Flags = data.SoundFlags; |
4598 | } | 4572 | } |
4599 | 4573 | ||
4600 | switch ((PCode)data.primShape.PCode) | 4574 | switch ((PCode)data.Shape.PCode) |
4601 | { | 4575 | { |
4602 | case PCode.Grass: | 4576 | case PCode.Grass: |
4603 | case PCode.Tree: | 4577 | case PCode.Tree: |
4604 | case PCode.NewTree: | 4578 | case PCode.NewTree: |
4605 | update.Data = new byte[] { data.primShape.State }; | 4579 | update.Data = new byte[] { data.Shape.State }; |
4606 | break; | 4580 | break; |
4607 | default: | 4581 | default: |
4608 | // TODO: Support ScratchPad | ||
4609 | //if (prim.ScratchPad != null) | ||
4610 | //{ | ||
4611 | // update.Data = new byte[prim.ScratchPad.Length]; | ||
4612 | // Buffer.BlockCopy(prim.ScratchPad, 0, update.Data, 0, update.Data.Length); | ||
4613 | //} | ||
4614 | //else | ||
4615 | //{ | ||
4616 | // update.Data = Utils.EmptyBytes; | ||
4617 | //} | ||
4618 | update.Data = Utils.EmptyBytes; | 4582 | update.Data = Utils.EmptyBytes; |
4619 | break; | 4583 | break; |
4620 | } | 4584 | } |
@@ -4622,6 +4586,12 @@ namespace OpenSim.Region.ClientStack.LindenUDP | |||
4622 | return update; | 4586 | return update; |
4623 | } | 4587 | } |
4624 | 4588 | ||
4589 | protected ObjectUpdateCompressedPacket.ObjectDataBlock CreateCompressedUpdateBlock(SceneObjectPart part, PrimUpdateFlags updateFlags) | ||
4590 | { | ||
4591 | // TODO: Implement this | ||
4592 | return null; | ||
4593 | } | ||
4594 | |||
4625 | public void SendNameReply(UUID profileId, string firstname, string lastname) | 4595 | public void SendNameReply(UUID profileId, string firstname, string lastname) |
4626 | { | 4596 | { |
4627 | UUIDNameReplyPacket packet = (UUIDNameReplyPacket)PacketPool.Instance.GetPacket(PacketType.UUIDNameReply); | 4597 | UUIDNameReplyPacket packet = (UUIDNameReplyPacket)PacketPool.Instance.GetPacket(PacketType.UUIDNameReply); |
@@ -11644,7 +11614,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP | |||
11644 | throw new InvalidOperationException(string.Format("The {0} is empty", this.GetType().ToString())); | 11614 | throw new InvalidOperationException(string.Format("The {0} is empty", this.GetType().ToString())); |
11645 | } | 11615 | } |
11646 | 11616 | ||
11647 | internal TValue Dequeue() | 11617 | internal bool TryDequeue(out TValue value) |
11648 | { | 11618 | { |
11649 | for (int i = 0; i < m_heaps.Length; ++i) | 11619 | for (int i = 0; i < m_heaps.Length; ++i) |
11650 | { | 11620 | { |
@@ -11652,10 +11622,13 @@ namespace OpenSim.Region.ClientStack.LindenUDP | |||
11652 | { | 11622 | { |
11653 | MinHeapItem item = m_heaps[i].RemoveMin(); | 11623 | MinHeapItem item = m_heaps[i].RemoveMin(); |
11654 | m_lookupTable.Remove(item.LocalID); | 11624 | m_lookupTable.Remove(item.LocalID); |
11655 | return item.Value; | 11625 | value = item.Value; |
11626 | return true; | ||
11656 | } | 11627 | } |
11657 | } | 11628 | } |
11658 | throw new InvalidOperationException(string.Format("The {0} is empty", this.GetType().ToString())); | 11629 | |
11630 | value = default(TValue); | ||
11631 | return false; | ||
11659 | } | 11632 | } |
11660 | 11633 | ||
11661 | internal void Reprioritize(UpdatePriorityHandler handler) | 11634 | internal void Reprioritize(UpdatePriorityHandler handler) |