public void UpdateAttachmentPosition(IClientAPI client, SceneObjectGroup sog, Vector3 pos) { // If this is an attachment, then we need to save the modified // object back into the avatar's inventory. First we save the // attachment point information, then we update the relative // positioning (which caused this method to get driven in the // first place. Then we have to mark the object as NOT an // attachment. This is necessary in order to correctly save // and retrieve GroupPosition information for the attachment. // Then we save the asset back into the appropriate inventory // entry. Finally, we restore the object's attachment status. byte attachmentPoint = (byte)sog.RootPart.AttachmentPoint; sog.UpdateGroupPosition(pos, true); sog.RootPart.IsAttachment = false; sog.AbsolutePosition = sog.RootPart.AttachedPos; UpdateKnownItem(client, sog, sog.GetFromItemID(), sog.OwnerID); sog.SetAttachmentPoint(attachmentPoint); }
public bool AttachObject(IClientAPI remoteClient, SceneObjectGroup group, int AttachmentPt, bool silent) { Vector3 attachPos = group.AbsolutePosition; if (m_scene.Permissions.CanTakeObject(group.UUID, remoteClient.AgentId)) { // TODO: this short circuits multiple attachments functionality in LL viewer 2.1+ and should // be removed when that functionality is implemented in opensim AttachmentPt &= 0x7f; // If the attachment point isn't the same as the one previously used // set it's offset position = 0 so that it appears on the attachment point // and not in a weird location somewhere unknown. if (AttachmentPt != 0 && AttachmentPt != (int)group.GetAttachmentPoint()) { attachPos = Vector3.Zero; } // AttachmentPt 0 means the client chose to 'wear' the attachment. /*if (AttachmentPt == 0) { // Check object for stored attachment point AttachmentPt = (int)group.GetAttachmentPoint(); attachPos = group.GetAttachmentPos(); }*/ if (AttachmentPt == 0) { // Check object for older stored attachment point AttachmentPt = group.RootPart.Shape.State; //attachPos = group.AbsolutePosition; } // if we still didn't find a suitable attachment point....... if (AttachmentPt == 0) { // Stick it on right hand with Zero Offset from the attachment point. AttachmentPt = (int)AttachmentPoint.RightHand; attachPos = Vector3.Zero; } group.SetAttachmentPoint((byte)AttachmentPt); group.AbsolutePosition = attachPos; // Remove any previous attachments ScenePresence sp = m_scene.GetScenePresence(remoteClient.AgentId); UUID itemID = UUID.Zero; if (sp != null) { foreach (SceneObjectGroup grp in sp.GetAttachments(AttachmentPt)) { itemID = grp.GetFromItemID(); if (itemID != UUID.Zero) DetachSingleAttachmentToInv(itemID, remoteClient); } } if (group.GetFromItemID() == UUID.Zero) { m_scene.attachObjectAssetStore(remoteClient, group, remoteClient.AgentId, out itemID); } else { itemID = group.GetFromItemID(); } ShowAttachInUserInventory(remoteClient, AttachmentPt, itemID, group); AttachToAgent(sp, group, AttachmentPt, attachPos, silent); } else { remoteClient.SendAgentAlertMessage( "You don't have sufficient permissions to attach this object", false); return false; } return true; }
/// <summary> /// Update the attachment asset for the new sog details if they have changed. /// </summary> /// <remarks> /// This is essential for preserving attachment attributes such as permission. Unlike normal scene objects, /// these details are not stored on the region. /// </remarks> /// <param name="sp"></param> /// <param name="grp"></param> private void UpdateKnownItem(IScenePresence sp, SceneObjectGroup grp) { if (grp.HasGroupChanged || grp.ContainsScripts()) { m_log.DebugFormat( "[ATTACHMENTS MODULE]: Updating asset for attachment {0}, attachpoint {1}", grp.UUID, grp.AttachmentPoint); string sceneObjectXml = SceneObjectSerializer.ToOriginalXmlFormat(grp); InventoryItemBase item = new InventoryItemBase(grp.GetFromItemID(), sp.UUID); item = m_scene.InventoryService.GetItem(item); if (item != null) { AssetBase asset = m_scene.CreateAsset( grp.GetPartName(grp.LocalId), grp.GetPartDescription(grp.LocalId), (sbyte)AssetType.Object, Utils.StringToBytes(sceneObjectXml), sp.UUID); m_scene.AssetService.Store(asset); item.AssetID = asset.FullID; item.Description = asset.Description; item.Name = asset.Name; item.AssetType = asset.Type; item.InvType = (int)InventoryType.Object; m_scene.InventoryService.UpdateItem(item); // this gets called when the agent logs off! if (sp.ControllingClient != null) sp.ControllingClient.SendInventoryItemCreateUpdate(item, 0); } } else { m_log.DebugFormat( "[ATTACHMENTS MODULE]: Don't need to update asset for unchanged attachment {0}, attachpoint {1}", grp.UUID, grp.AttachmentPoint); } }
public bool AttachObject(IScenePresence sp, SceneObjectGroup group, uint attachmentPt, bool silent) { lock (sp.AttachmentsSyncLock) { // m_log.DebugFormat( // "[ATTACHMENTS MODULE]: Attaching object {0} {1} to {2} point {3} from ground (silent = {4})", // group.Name, group.LocalId, sp.Name, attachmentPt, silent); if (sp.GetAttachments(attachmentPt).Contains(group)) { // m_log.WarnFormat( // "[ATTACHMENTS MODULE]: Ignoring request to attach {0} {1} to {2} on {3} since it's already attached", // group.Name, group.LocalId, sp.Name, AttachmentPt); return false; } Vector3 attachPos = group.AbsolutePosition; // TODO: this short circuits multiple attachments functionality in LL viewer 2.1+ and should // be removed when that functionality is implemented in opensim attachmentPt &= 0x7f; // If the attachment point isn't the same as the one previously used // set it's offset position = 0 so that it appears on the attachment point // and not in a weird location somewhere unknown. if (attachmentPt != 0 && attachmentPt != group.AttachmentPoint) { attachPos = Vector3.Zero; } // AttachmentPt 0 means the client chose to 'wear' the attachment. if (attachmentPt == 0) { // Check object for stored attachment point attachmentPt = group.AttachmentPoint; } // if we still didn't find a suitable attachment point....... if (attachmentPt == 0) { // Stick it on left hand with Zero Offset from the attachment point. attachmentPt = (uint)AttachmentPoint.LeftHand; attachPos = Vector3.Zero; } group.AttachmentPoint = attachmentPt; group.AbsolutePosition = attachPos; // We also don't want to do any of the inventory operations for an NPC. if (sp.PresenceType != PresenceType.Npc) { // Remove any previous attachments List<SceneObjectGroup> attachments = sp.GetAttachments(attachmentPt); // At the moment we can only deal with a single attachment if (attachments.Count != 0) { UUID oldAttachmentItemID = attachments[0].GetFromItemID(); if (oldAttachmentItemID != UUID.Zero) DetachSingleAttachmentToInvInternal(sp, oldAttachmentItemID); else m_log.WarnFormat( "[ATTACHMENTS MODULE]: When detaching existing attachment {0} {1} at point {2} to make way for {3} {4} for {5}, couldn't find the associated item ID to adjust inventory attachment record!", attachments[0].Name, attachments[0].LocalId, attachmentPt, group.Name, group.LocalId, sp.Name); } // Add the new attachment to inventory if we don't already have it. UUID newAttachmentItemID = group.GetFromItemID(); if (newAttachmentItemID == UUID.Zero) newAttachmentItemID = AddSceneObjectAsNewAttachmentInInv(sp, group).ID; ShowAttachInUserInventory(sp, attachmentPt, newAttachmentItemID, group); } AttachToAgent(sp, group, attachmentPt, attachPos, silent); } return true; }
/// <summary> /// Attach the object to the avatar /// </summary> /// <param name="remoteClient">The client that is having the attachment done</param> /// <param name="localID">The localID (SceneObjectPart) that is being attached (for the attach script event)</param> /// <param name="group">The group (SceneObjectGroup) that is being attached</param> /// <param name="AttachmentPt">The point to where the attachment will go</param> /// <param name="item">If this is not null, it saves a query in this method to the InventoryService /// This is the Item that the object is in (if it is in one yet)</param> protected void FindAttachmentPoint(IClientAPI remoteClient, uint localID, SceneObjectGroup group, int AttachmentPt, InventoryItemBase item) { //Make sure that we arn't over the limit of attachments SceneObjectGroup[] attachments = GetAttachmentsForAvatar(remoteClient.AgentId); if (attachments.Length + 1 > m_maxNumberOfAttachments) { //Too many remoteClient.SendAgentAlertMessage( "You are wearing too many attachments. Take one off to attach this object", false); return; } Vector3 attachPos = group.GetAttachmentPos(); if(!m_allowMultipleAttachments) AttachmentPt &= 0x7f; //Disable it! //Did the attachment change position or attachment point? bool changedPositionPoint = false; // If the attachment point isn't the same as the one previously used // set it's offset position = 0 so that it appears on the attachment point // and not in a weird location somewhere unknown. //Simplier terms: the attachment point changed, set it to the default 0,0,0 location if ((AttachmentPt & 0x7f) != 0 && (AttachmentPt & 0x7f) != (int)group.GetAttachmentPoint()) { attachPos = Vector3.Zero; changedPositionPoint = true; } else { // AttachmentPt 0 means the client chose to 'wear' the attachment. if ((AttachmentPt & 0x7f) == 0) { // Check object for stored attachment point AttachmentPt = (int)group.GetSavedAttachmentPoint(); attachPos = group.GetAttachmentPos(); } //Check state afterwards... use the newer GetSavedAttachmentPoint and Pos above first if ((AttachmentPt & 0x7f) == 0) { // Check object for older stored attachment point AttachmentPt = group.RootPart.Shape.State; //attachPos = group.AbsolutePosition; } // if we still didn't find a suitable attachment point, force it to the default //This happens on the first time an avatar 'wears' an object if ((AttachmentPt & 0x7f) == 0) { // Stick it on right hand with Zero Offset from the attachment point. AttachmentPt = (int)AttachmentPoint.RightHand; //Default location attachPos = Vector3.Zero; changedPositionPoint = true; } } group.HasGroupChanged = changedPositionPoint; //Update where we are put group.SetAttachmentPoint((byte)AttachmentPt); //Fix the position with the one we found group.AbsolutePosition = attachPos; // Remove any previous attachments ScenePresence presence = m_scene.GetScenePresence(remoteClient.AgentId); if (presence == null) return; UUID itemID = UUID.Zero; //Check for multiple attachment bits //If the numbers are the same, it wants to have the old attachment taken off if ((AttachmentPt & 0x7f) == AttachmentPt) { foreach (SceneObjectGroup grp in attachments) { if (grp.GetAttachmentPoint() == (byte)AttachmentPt) { itemID = grp.GetFromItemID(); break; } } if (itemID != UUID.Zero) DetachSingleAttachmentToInventory(itemID, remoteClient); } itemID = group.GetFromItemID(); group.RootPart.AttachedAvatar = presence.UUID; //Anakin Lohner bug #3839 SceneObjectPart[] parts = group.Parts; for (int i = 0; i < parts.Length; i++) parts[i].AttachedAvatar = presence.UUID; if (group.RootPart.PhysActor != null) { m_scene.SceneGraph.PhysicsScene.RemovePrim(group.RootPart.PhysActor); group.RootPart.PhysActor = null; } group.AbsolutePosition = attachPos; group.RootPart.AttachedPos = attachPos; group.RootPart.IsAttachment = true; group.RootPart.SetParentLocalId(presence.LocalId); group.SetAttachmentPoint(Convert.ToByte(AttachmentPt)); AvatarAttachments attPlugin = presence.RequestModuleInterface<AvatarAttachments>(); if (attPlugin != null) attPlugin.AddAttachment(group); // Killing it here will cause the client to deselect it // It then reappears on the avatar, deselected // through the full update below // if (group.IsSelected) { foreach (SceneObjectPart part in group.ChildrenList) { part.CreateSelected = true; } } //Kill the previous entity so that it will be selected SendKillEntity(group.RootPart); //NOTE: This MUST be here, otherwise we limit full updates during attachments when they are selected and it will block the first update. // So until that is changed, this MUST stay. The client will instantly reselect it, so this value doesn't stay borked for long. group.IsSelected = false; if (itemID == UUID.Zero) { //Delete the object inworld to inventory List<SceneObjectGroup> groups = new List<SceneObjectGroup>(1) { group }; IInventoryAccessModule inventoryAccess = m_scene.RequestModuleInterface<IInventoryAccessModule>(); if (inventoryAccess != null) inventoryAccess.DeleteToInventory(DeRezAction.AcquireToUserInventory, UUID.Zero, groups, remoteClient.AgentId, out itemID); } else { //it came from an item, we need to start the scripts // Fire after attach, so we don't get messy perms dialogs // 4 == AttachedRez group.CreateScriptInstances(0, true, 4, UUID.Zero); group.ResumeScripts(); } if (UUID.Zero == itemID) { m_log.Error("[ATTACHMENTS MODULE]: Unable to save attachment. Error inventory item ID."); remoteClient.SendAgentAlertMessage( "Unable to save attachment. Error inventory item ID.", false); return; } // XXYY!! if (item == null) { item = new InventoryItemBase(itemID, remoteClient.AgentId); item = m_scene.InventoryService.GetItem(item); } //Update the ItemID with the new item group.SetFromItemID(item.ID); //If we updated the attachment, we need to save the change if (presence.Appearance.SetAttachment((int)AttachmentPt, itemID, item.AssetID)) AvatarFactory.QueueAppearanceSave(remoteClient.AgentId); //Now recreate it so that it is selected group.ScheduleGroupUpdate(PrimUpdateFlags.FullUpdate); // In case it is later dropped again, don't let // it get cleaned up group.RootPart.RemFlag(PrimFlags.TemporaryOnRez); group.HasGroupChanged = false; m_scene.EventManager.TriggerOnAttach(localID, group.GetFromItemID(), remoteClient.AgentId); }
/// <summary> /// Adds a Scene Object group to the Scene. /// Verifies that the creator of the object is not banned from the simulator. /// Checks if the item is an Attachment /// </summary> /// <param name="sceneObject"></param> /// <returns>True if the SceneObjectGroup was added, False if it was not</returns> public bool AddSceneObject(SceneObjectGroup sceneObject) { // If the user is banned, we won't let any of their objects // enter. Period. // if (m_regInfo.EstateSettings.IsBanned(sceneObject.OwnerID)) { m_log.Info("[INTERREGION]: Denied prim crossing for " + "banned avatar"); return false; } if (sceneObject.IsAttachmentCheckFull()) // Attachment { sceneObject.RootPart.AddFlag(PrimFlags.TemporaryOnRez); sceneObject.RootPart.AddFlag(PrimFlags.Phantom); AddPrimToScene(sceneObject); // Fix up attachment Parent Local ID ScenePresence sp = GetScenePresence(sceneObject.OwnerID); if (sp != null) { m_log.DebugFormat( "[ATTACHMENT]: Received attachment {0}, inworld asset id {1}", sceneObject.GetFromItemID(), sceneObject.UUID); m_log.DebugFormat( "[ATTACHMENT]: Attach to avatar {0} at position {1}", sp.UUID, sceneObject.AbsolutePosition); if (AttachmentsModule != null) AttachmentsModule.AttachObject(sp.ControllingClient, sceneObject.LocalId, 0, false); sceneObject.RootPart.RemFlag(PrimFlags.TemporaryOnRez); } else { sceneObject.RootPart.RemFlag(PrimFlags.TemporaryOnRez); sceneObject.RootPart.AddFlag(PrimFlags.TemporaryOnRez); } } else { if (!Permissions.CanObjectEntry(sceneObject.UUID, true, sceneObject.AbsolutePosition)) { // Deny non attachments based on parcel settings // m_log.Info("[INTERREGION]: Denied prim crossing " + "because of parcel settings"); DeleteSceneObject(sceneObject, false, true); return false; } AddPrimToScene(sceneObject); } sceneObject.SendGroupFullUpdate(PrimUpdateFlags.FullUpdate); return true; }