/* * Copyright (c) Contributors, http://opensimulator.org/ * See CONTRIBUTORS.TXT for a full list of copyright holders. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * * Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * Neither the name of the OpenSimulator Project nor the * names of its contributors may be used to endorse or promote products * derived from this software without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ using System; using System.Threading; using System.Collections.Generic; using System.Reflection; using OpenMetaverse; using OpenMetaverse.Packets; using log4net; using OpenSim.Framework; using OpenSim.Region.Framework.Scenes.Types; using OpenSim.Region.PhysicsModules.SharedBase; using OpenSim.Region.Framework.Interfaces; namespace OpenSim.Region.Framework.Scenes { public delegate void PhysicsCrash(); public delegate void AttachToBackupDelegate(SceneObjectGroup sog); public delegate void DetachFromBackupDelegate(SceneObjectGroup sog); public delegate void ChangedBackupDelegate(SceneObjectGroup sog); /// <summary> /// This class used to be called InnerScene and may not yet truly be a SceneGraph. The non scene graph components /// should be migrated out over time. /// </summary> public class SceneGraph { private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType); #region Events protected internal event PhysicsCrash UnRecoverableError; private PhysicsCrash handlerPhysicsCrash = null; public event AttachToBackupDelegate OnAttachToBackup; public event DetachFromBackupDelegate OnDetachFromBackup; public event ChangedBackupDelegate OnChangeBackup; #endregion #region Fields protected OpenMetaverse.ReaderWriterLockSlim m_scenePresencesLock = new OpenMetaverse.ReaderWriterLockSlim(); protected Dictionary<UUID, ScenePresence> m_scenePresenceMap = new Dictionary<UUID, ScenePresence>(); protected List<ScenePresence> m_scenePresenceArray = new List<ScenePresence>(); protected internal EntityManager Entities = new EntityManager(); protected Scene m_parentScene; protected Dictionary<UUID, SceneObjectGroup> m_updateList = new Dictionary<UUID, SceneObjectGroup>(); protected int m_numRootAgents = 0; protected int m_numTotalPrim = 0; protected int m_numPrim = 0; protected int m_numMesh = 0; protected int m_numChildAgents = 0; protected int m_physicalPrim = 0; protected int m_activeScripts = 0; protected int m_scriptLPS = 0; protected internal PhysicsScene _PhyScene; /// <summary> /// Index the SceneObjectGroup for each part by the root part's UUID. /// </summary> protected internal Dictionary<UUID, SceneObjectGroup> SceneObjectGroupsByFullID = new Dictionary<UUID, SceneObjectGroup>(); /// <summary> /// Index the SceneObjectGroup for each part by that part's UUID. /// </summary> protected internal Dictionary<UUID, SceneObjectGroup> SceneObjectGroupsByFullPartID = new Dictionary<UUID, SceneObjectGroup>(); /// <summary> /// Index the SceneObjectGroup for each part by that part's local ID. /// </summary> protected internal Dictionary<uint, SceneObjectGroup> SceneObjectGroupsByLocalPartID = new Dictionary<uint, SceneObjectGroup>(); /// <summary> /// Lock to prevent object group update, linking, delinking and duplication operations from running concurrently. /// </summary> /// <remarks> /// These operations rely on the parts composition of the object. If allowed to run concurrently then race /// conditions can occur. /// </remarks> private Object m_updateLock = new Object(); #endregion protected internal SceneGraph(Scene parent) { m_parentScene = parent; } public PhysicsScene PhysicsScene { get { if (_PhyScene == null) _PhyScene = m_parentScene.RequestModuleInterface<PhysicsScene>(); return _PhyScene; } set { // If we're not doing the initial set // Then we've got to remove the previous // event handler if (_PhyScene != null) _PhyScene.OnPhysicsCrash -= physicsBasedCrash; _PhyScene = value; if (_PhyScene != null) _PhyScene.OnPhysicsCrash += physicsBasedCrash; } } protected internal void Close() { m_scenePresencesLock.EnterWriteLock(); try { Dictionary<UUID, ScenePresence> newmap = new Dictionary<UUID, ScenePresence>(); List<ScenePresence> newlist = new List<ScenePresence>(); m_scenePresenceMap = newmap; m_scenePresenceArray = newlist; } finally { m_scenePresencesLock.ExitWriteLock(); } lock (SceneObjectGroupsByFullID) SceneObjectGroupsByFullID.Clear(); lock (SceneObjectGroupsByFullPartID) SceneObjectGroupsByFullPartID.Clear(); lock (SceneObjectGroupsByLocalPartID) SceneObjectGroupsByLocalPartID.Clear(); Entities.Clear(); } #region Update Methods protected internal void UpdatePreparePhysics() { // If we are using a threaded physics engine // grab the latest scene from the engine before // trying to process it. // PhysX does this (runs in the background). if (PhysicsScene.IsThreaded) { PhysicsScene.GetResults(); } } /// <summary> /// Update the position of all the scene presences. /// </summary> /// <remarks> /// Called only from the main scene loop. /// </remarks> protected internal void UpdatePresences() { ForEachScenePresence(delegate(ScenePresence presence) { presence.Update(); }); } /// <summary> /// Perform a physics frame update. /// </summary> /// <param name="elapsed"></param> /// <returns></returns> protected internal float UpdatePhysics(double elapsed) { // Here is where the Scene calls the PhysicsScene. This is a one-way // interaction; the PhysicsScene cannot access the calling Scene directly. // But with joints, we want a PhysicsActor to be able to influence a // non-physics SceneObjectPart. In particular, a PhysicsActor that is connected // with a joint should be able to move the SceneObjectPart which is the visual // representation of that joint (for editing and serialization purposes). // However the PhysicsActor normally cannot directly influence anything outside // of the PhysicsScene, and the non-physical SceneObjectPart which represents // the joint in the Scene does not exist in the PhysicsScene. // // To solve this, we have an event in the PhysicsScene that is fired when a joint // has changed position (because one of its associated PhysicsActors has changed // position). // // Therefore, JointMoved and JointDeactivated events will be fired as a result of the following Simulate(). return PhysicsScene.Simulate((float)elapsed); } protected internal void ProcessPhysicsPreSimulation() { if(PhysicsScene != null) PhysicsScene.ProcessPreSimulation(); } protected internal void UpdateScenePresenceMovement() { ForEachScenePresence(delegate(ScenePresence presence) { presence.UpdateMovement(); }); } public void GetCoarseLocations(out List<Vector3> coarseLocations, out List<UUID> avatarUUIDs, uint maxLocations) { coarseLocations = new List<Vector3>(); avatarUUIDs = new List<UUID>(); // coarse locations are sent as BYTE, so limited to the 255m max of normal regions // try to work around that scale down X and Y acording to region size, so reducing the resolution // // viewers need to scale up float scaleX = (float)m_parentScene.RegionInfo.RegionSizeX / (float)Constants.RegionSize; if (scaleX == 0) scaleX = 1.0f; scaleX = 1.0f / scaleX; float scaleY = (float)m_parentScene.RegionInfo.RegionSizeY / (float)Constants.RegionSize; if (scaleY == 0) scaleY = 1.0f; scaleY = 1.0f / scaleY; List<ScenePresence> presences = GetScenePresences(); for (int i = 0; i < Math.Min(presences.Count, maxLocations); ++i) { ScenePresence sp = presences[i]; // If this presence is a child agent, we don't want its coarse locations if (sp.IsChildAgent) continue; Vector3 pos = sp.AbsolutePosition; pos.X *= scaleX; pos.Y *= scaleY; coarseLocations.Add(pos); avatarUUIDs.Add(sp.UUID); } } #endregion #region Entity Methods /// <summary> /// Add an object into the scene that has come from storage /// </summary> /// <param name="sceneObject"></param> /// <param name="attachToBackup"> /// If true, changes to the object will be reflected in its persisted data /// If false, the persisted data will not be changed even if the object in the scene is changed /// </param> /// <param name="alreadyPersisted"> /// If true, we won't persist this object until it changes /// If false, we'll persist this object immediately /// </param> /// <param name="sendClientUpdates"> /// If true, we send updates to the client to tell it about this object /// If false, we leave it up to the caller to do this /// </param> /// <returns> /// true if the object was added, false if an object with the same uuid was already in the scene /// </returns> protected internal bool AddRestoredSceneObject( SceneObjectGroup sceneObject, bool attachToBackup, bool alreadyPersisted, bool sendClientUpdates) { // temporary checks to remove after varsize suport float regionSizeX = m_parentScene.RegionInfo.RegionSizeX; if (regionSizeX == 0) regionSizeX = Constants.RegionSize; float regionSizeY = m_parentScene.RegionInfo.RegionSizeY; if (regionSizeY == 0) regionSizeY = Constants.RegionSize; // KF: Check for out-of-region, move inside and make static. Vector3 npos = new Vector3(sceneObject.RootPart.GroupPosition.X, sceneObject.RootPart.GroupPosition.Y, sceneObject.RootPart.GroupPosition.Z); bool clampZ = m_parentScene.ClampNegativeZ; if (!(((sceneObject.RootPart.Shape.PCode == (byte)PCode.Prim) && (sceneObject.RootPart.Shape.State != 0))) && (npos.X < 0.0 || npos.Y < 0.0 || (npos.Z < 0.0 && clampZ) || npos.X > regionSizeX || npos.Y > regionSizeY)) { if (npos.X < 0.0) npos.X = 1.0f; if (npos.Y < 0.0) npos.Y = 1.0f; if (npos.Z < 0.0 && clampZ) npos.Z = 0.0f; if (npos.X > regionSizeX) npos.X = regionSizeX - 1.0f; if (npos.Y > regionSizeY) npos.Y = regionSizeY - 1.0f; SceneObjectPart rootpart = sceneObject.RootPart; rootpart.GroupPosition = npos; foreach (SceneObjectPart part in sceneObject.Parts) { if (part == rootpart) continue; part.GroupPosition = npos; } rootpart.Velocity = Vector3.Zero; rootpart.AngularVelocity = Vector3.Zero; rootpart.Acceleration = Vector3.Zero; } bool ret = AddSceneObject(sceneObject, attachToBackup, sendClientUpdates); if (attachToBackup && (!alreadyPersisted)) { sceneObject.ForceInventoryPersistence(); sceneObject.HasGroupChanged = true; } return ret; } /// <summary> /// Add a newly created object to the scene. This will both update the scene, and send information about the /// new object to all clients interested in the scene. /// </summary> /// <param name="sceneObject"></param> /// <param name="attachToBackup"> /// If true, the object is made persistent into the scene. /// If false, the object will not persist over server restarts /// </param> /// <returns> /// true if the object was added, false if an object with the same uuid was already in the scene /// </returns> protected internal bool AddNewSceneObject(SceneObjectGroup sceneObject, bool attachToBackup, bool sendClientUpdates) { bool ret = AddSceneObject(sceneObject, attachToBackup, sendClientUpdates); // Ensure that we persist this new scene object if it's not an // attachment if (attachToBackup) sceneObject.HasGroupChanged = true; return ret; } /// <summary> /// Add a newly created object to the scene. /// </summary> /// /// This method does not send updates to the client - callers need to handle this themselves. /// Caller should also trigger EventManager.TriggerObjectAddedToScene /// <param name="sceneObject"></param> /// <param name="attachToBackup"></param> /// <param name="pos">Position of the object. If null then the position stored in the object is used.</param> /// <param name="rot">Rotation of the object. If null then the rotation stored in the object is used.</param> /// <param name="vel">Velocity of the object. This parameter only has an effect if the object is physical</param> /// <returns></returns> public bool AddNewSceneObject( SceneObjectGroup sceneObject, bool attachToBackup, Vector3? pos, Quaternion? rot, Vector3 vel) { AddNewSceneObject(sceneObject, attachToBackup, false); if (pos != null) sceneObject.AbsolutePosition = (Vector3)pos; if (sceneObject.RootPart.Shape.PCode == (byte)PCode.Prim) { sceneObject.ClearPartAttachmentData(); } if (rot != null) sceneObject.UpdateGroupRotationR((Quaternion)rot); PhysicsActor pa = sceneObject.RootPart.PhysActor; if (pa != null && pa.IsPhysical && vel != Vector3.Zero) { sceneObject.RootPart.ApplyImpulse((vel * sceneObject.GetMass()), false); } return true; } /// <summary> /// Add an object to the scene. This will both update the scene, and send information about the /// new object to all clients interested in the scene. /// </summary> /// <remarks> /// The object's stored position, rotation and velocity are used. /// </remarks> /// <param name="sceneObject"></param> /// <param name="attachToBackup"> /// If true, the object is made persistent into the scene. /// If false, the object will not persist over server restarts /// </param> /// <param name="sendClientUpdates"> /// If true, updates for the new scene object are sent to all viewers in range. /// If false, it is left to the caller to schedule the update /// </param> /// <returns> /// true if the object was added, false if an object with the same uuid was already in the scene /// </returns> protected bool AddSceneObject(SceneObjectGroup sceneObject, bool attachToBackup, bool sendClientUpdates) { if (sceneObject == null) { m_log.ErrorFormat("[SCENEGRAPH]: Tried to add null scene object"); return false; } if (sceneObject.UUID == UUID.Zero) { m_log.ErrorFormat( "[SCENEGRAPH]: Tried to add scene object {0} to {1} with illegal UUID of {2}", sceneObject.Name, m_parentScene.RegionInfo.RegionName, UUID.Zero); return false; } if (Entities.ContainsKey(sceneObject.UUID)) { m_log.DebugFormat( "[SCENEGRAPH]: Scene graph for {0} already contains object {1} in AddSceneObject()", m_parentScene.RegionInfo.RegionName, sceneObject.UUID); return false; } // m_log.DebugFormat( // "[SCENEGRAPH]: Adding scene object {0} {1}, with {2} parts on {3}", // sceneObject.Name, sceneObject.UUID, sceneObject.Parts.Length, m_parentScene.RegionInfo.RegionName); SceneObjectPart[] parts = sceneObject.Parts; // Clamp the sizes (scales) of the child prims and add the child prims to the count of all primitives // (meshes and geometric primitives) in the scene; add child prims to m_numTotalPrim count if (m_parentScene.m_clampPrimSize) { foreach (SceneObjectPart part in parts) { Vector3 scale = part.Shape.Scale; scale.X = Util.Clamp(scale.X, m_parentScene.m_minNonphys, m_parentScene.m_maxNonphys); scale.Y = Util.Clamp(scale.Y, m_parentScene.m_minNonphys, m_parentScene.m_maxNonphys); scale.Z = Util.Clamp(scale.Z, m_parentScene.m_minNonphys, m_parentScene.m_maxNonphys); part.Shape.Scale = scale; } } m_numTotalPrim += parts.Length; // Go through all parts (geometric primitives and meshes) of this Scene Object foreach (SceneObjectPart part in parts) { // Keep track of the total number of meshes or geometric primitives now in the scene; // determine which object this is based on its primitive type: sculpted (sculpt) prim refers to // a mesh and all other prims (i.e. box, sphere, etc) are geometric primitives if (part.GetPrimType() == PrimType.SCULPT) m_numMesh++; else m_numPrim++; } sceneObject.AttachToScene(m_parentScene); Entities.Add(sceneObject); lock (SceneObjectGroupsByFullID) SceneObjectGroupsByFullID[sceneObject.UUID] = sceneObject; foreach (SceneObjectPart part in parts) { lock (SceneObjectGroupsByFullPartID) SceneObjectGroupsByFullPartID[part.UUID] = sceneObject; lock (SceneObjectGroupsByLocalPartID) SceneObjectGroupsByLocalPartID[part.LocalId] = sceneObject; } if (sendClientUpdates) sceneObject.ScheduleGroupForFullUpdate(); if (attachToBackup) sceneObject.AttachToBackup(); return true; } public void updateScenePartGroup(SceneObjectPart part, SceneObjectGroup grp) { // no tests, caller has responsability... lock (SceneObjectGroupsByFullPartID) SceneObjectGroupsByFullPartID[part.UUID] = grp; lock (SceneObjectGroupsByLocalPartID) SceneObjectGroupsByLocalPartID[part.LocalId] = grp; } /// <summary> /// Delete an object from the scene /// </summary> /// <returns>true if the object was deleted, false if there was no object to delete</returns> public bool DeleteSceneObject(UUID uuid, bool resultOfObjectLinked) { // m_log.DebugFormat( // "[SCENE GRAPH]: Deleting scene object with uuid {0}, resultOfObjectLinked = {1}", // uuid, resultOfObjectLinked); EntityBase entity; if (!Entities.TryGetValue(uuid, out entity) || (!(entity is SceneObjectGroup))) return false; SceneObjectGroup grp = (SceneObjectGroup)entity; if (entity == null) return false; if (!resultOfObjectLinked) { // Decrement the total number of primitives (meshes and geometric primitives) // that are part of the Scene Object being removed m_numTotalPrim -= grp.PrimCount; // Go through all parts (primitives and meshes) of this Scene Object foreach (SceneObjectPart part in grp.Parts) { // Keep track of the total number of meshes or geometric primitives left in the scene; // determine which object this is based on its primitive type: sculpted (sculpt) prim refers to // a mesh and all other prims (i.e. box, sphere, etc) are geometric primitives if (part.GetPrimType() == PrimType.SCULPT) m_numMesh--; else m_numPrim--; } if ((grp.RootPart.Flags & PrimFlags.Physics) == PrimFlags.Physics) RemovePhysicalPrim(grp.PrimCount); } bool ret = Entities.Remove(uuid); lock (SceneObjectGroupsByFullID) SceneObjectGroupsByFullID.Remove(grp.UUID); SceneObjectPart[] parts = grp.Parts; for (int i = 0; i < parts.Length; i++) { lock (SceneObjectGroupsByFullPartID) SceneObjectGroupsByFullPartID.Remove(parts[i].UUID); lock (SceneObjectGroupsByLocalPartID) SceneObjectGroupsByLocalPartID.Remove(parts[i].LocalId); } return ret; } /// <summary> /// Add an object to the list of prims to process on the next update /// </summary> /// <param name="obj"> /// A <see cref="SceneObjectGroup"/> /// </param> protected internal void AddToUpdateList(SceneObjectGroup obj) { lock (m_updateList) m_updateList[obj.UUID] = obj; } public void FireAttachToBackup(SceneObjectGroup obj) { if (OnAttachToBackup != null) { OnAttachToBackup(obj); } } public void FireDetachFromBackup(SceneObjectGroup obj) { if (OnDetachFromBackup != null) { OnDetachFromBackup(obj); } } public void FireChangeBackup(SceneObjectGroup obj) { if (OnChangeBackup != null) { OnChangeBackup(obj); } } /// <summary> /// Process all pending updates /// </summary> protected internal void UpdateObjectGroups() { if (!Monitor.TryEnter(m_updateLock)) return; try { List<SceneObjectGroup> updates; // Some updates add more updates to the updateList. // Get the current list of updates and clear the list before iterating lock (m_updateList) { updates = new List<SceneObjectGroup>(m_updateList.Values); m_updateList.Clear(); } // Go through all updates for (int i = 0; i < updates.Count; i++) { SceneObjectGroup sog = updates[i]; // Don't abort the whole update if one entity happens to give us an exception. try { sog.Update(); } catch (Exception e) { m_log.ErrorFormat( "[INNER SCENE]: Failed to update {0}, {1} - {2}", sog.Name, sog.UUID, e); } } } finally { Monitor.Exit(m_updateLock); } } protected internal void AddPhysicalPrim(int number) { m_physicalPrim += number; } protected internal void RemovePhysicalPrim(int number) { m_physicalPrim -= number; } protected internal void AddToScriptLPS(int number) { m_scriptLPS += number; } protected internal void AddActiveScripts(int number) { m_activeScripts += number; } protected internal void HandleUndo(IClientAPI remoteClient, UUID primId) { if (primId != UUID.Zero) { SceneObjectPart part = m_parentScene.GetSceneObjectPart(primId); if (part != null) part.Undo(); } } protected internal void HandleRedo(IClientAPI remoteClient, UUID primId) { if (primId != UUID.Zero) { SceneObjectPart part = m_parentScene.GetSceneObjectPart(primId); if (part != null) part.Redo(); } } protected internal ScenePresence CreateAndAddChildScenePresence( IClientAPI client, AvatarAppearance appearance, PresenceType type) { // ScenePresence always defaults to child agent ScenePresence presence = new ScenePresence(client, m_parentScene, appearance, type); Entities[presence.UUID] = presence; m_scenePresencesLock.EnterWriteLock(); try { m_numChildAgents++; Dictionary<UUID, ScenePresence> newmap = new Dictionary<UUID, ScenePresence>(m_scenePresenceMap); List<ScenePresence> newlist = new List<ScenePresence>(m_scenePresenceArray); if (!newmap.ContainsKey(presence.UUID)) { newmap.Add(presence.UUID, presence); newlist.Add(presence); } else { // Remember the old presence reference from the dictionary ScenePresence oldref = newmap[presence.UUID]; // Replace the presence reference in the dictionary with the new value newmap[presence.UUID] = presence; // Find the index in the list where the old ref was stored and update the reference newlist[newlist.IndexOf(oldref)] = presence; } // Swap out the dictionary and list with new references m_scenePresenceMap = newmap; m_scenePresenceArray = newlist; } finally { m_scenePresencesLock.ExitWriteLock(); } return presence; } /// <summary> /// Remove a presence from the scene /// </summary> protected internal void RemoveScenePresence(UUID agentID) { if (!Entities.Remove(agentID)) { m_log.WarnFormat( "[SCENE GRAPH]: Tried to remove non-existent scene presence with agent ID {0} from scene Entities list", agentID); } m_scenePresencesLock.EnterWriteLock(); try { Dictionary<UUID, ScenePresence> newmap = new Dictionary<UUID, ScenePresence>(m_scenePresenceMap); List<ScenePresence> newlist = new List<ScenePresence>(m_scenePresenceArray); // Remove the presence reference from the dictionary if (newmap.ContainsKey(agentID)) { ScenePresence oldref = newmap[agentID]; newmap.Remove(agentID); // Find the index in the list where the old ref was stored and remove the reference newlist.RemoveAt(newlist.IndexOf(oldref)); // Swap out the dictionary and list with new references m_scenePresenceMap = newmap; m_scenePresenceArray = newlist; } else { m_log.WarnFormat("[SCENE GRAPH]: Tried to remove non-existent scene presence with agent ID {0} from scene ScenePresences list", agentID); } } finally { m_scenePresencesLock.ExitWriteLock(); } } protected internal void SwapRootChildAgent(bool direction_RC_CR_T_F) { if (direction_RC_CR_T_F) { m_numRootAgents--; m_numChildAgents++; } else { m_numChildAgents--; m_numRootAgents++; } } public void removeUserCount(bool TypeRCTF) { if (TypeRCTF) { m_numRootAgents--; } else { m_numChildAgents--; } } public void RecalculateStats() { int rootcount = 0; int childcount = 0; ForEachScenePresence(delegate(ScenePresence presence) { if (presence.IsChildAgent) ++childcount; else ++rootcount; }); m_numRootAgents = rootcount; m_numChildAgents = childcount; } public int GetChildAgentCount() { return m_numChildAgents; } public int GetRootAgentCount() { return m_numRootAgents; } public int GetTotalObjectsCount() { return m_numTotalPrim; } public int GetTotalPrimObjectsCount() { return m_numPrim; } public int GetTotalMeshObjectsCount() { return m_numMesh; } public int GetActiveObjectsCount() { return m_physicalPrim; } public int GetActiveScriptsCount() { return m_activeScripts; } public int GetScriptLPS() { int returnval = m_scriptLPS; m_scriptLPS = 0; return returnval; } #endregion #region Get Methods /// <summary> /// Get the controlling client for the given avatar, if there is one. /// /// FIXME: The only user of the method right now is Caps.cs, in order to resolve a client API since it can't /// use the ScenePresence. This could be better solved in a number of ways - we could establish an /// OpenSim.Framework.IScenePresence, or move the caps code into a region package (which might be the more /// suitable solution). /// </summary> /// <param name="agentId"></param> /// <returns>null if either the avatar wasn't in the scene, or /// they do not have a controlling client</returns> /// <remarks>this used to be protected internal, but that /// prevents CapabilitiesModule from accessing it</remarks> public IClientAPI GetControllingClient(UUID agentId) { ScenePresence presence = GetScenePresence(agentId); if (presence != null) { return presence.ControllingClient; } return null; } /// <summary> /// Get a reference to the scene presence list. Changes to the list will be done in a copy /// There is no guarantee that presences will remain in the scene after the list is returned. /// This list should remain private to SceneGraph. Callers wishing to iterate should instead /// pass a delegate to ForEachScenePresence. /// </summary> /// <returns></returns> protected internal List<ScenePresence> GetScenePresences() { return m_scenePresenceArray; } /// <summary> /// Request a scene presence by UUID. Fast, indexed lookup. /// </summary> /// <param name="agentID"></param> /// <returns>null if the presence was not found</returns> protected internal ScenePresence GetScenePresence(UUID agentID) { Dictionary<UUID, ScenePresence> presences = m_scenePresenceMap; ScenePresence presence; presences.TryGetValue(agentID, out presence); return presence; } /// <summary> /// Request the scene presence by name. /// </summary> /// <param name="firstName"></param> /// <param name="lastName"></param> /// <returns>null if the presence was not found</returns> protected internal ScenePresence GetScenePresence(string firstName, string lastName) { List<ScenePresence> presences = GetScenePresences(); foreach (ScenePresence presence in presences) { if (string.Equals(presence.Firstname, firstName, StringComparison.CurrentCultureIgnoreCase) && string.Equals(presence.Lastname, lastName, StringComparison.CurrentCultureIgnoreCase)) return presence; } return null; } /// <summary> /// Request the scene presence by localID. /// </summary> /// <param name="localID"></param> /// <returns>null if the presence was not found</returns> protected internal ScenePresence GetScenePresence(uint localID) { List<ScenePresence> presences = GetScenePresences(); foreach (ScenePresence presence in presences) if (presence.LocalId == localID) return presence; return null; } protected internal bool TryGetScenePresence(UUID agentID, out ScenePresence avatar) { Dictionary<UUID, ScenePresence> presences = m_scenePresenceMap; presences.TryGetValue(agentID, out avatar); return (avatar != null); } protected internal bool TryGetAvatarByName(string name, out ScenePresence avatar) { avatar = null; foreach (ScenePresence presence in GetScenePresences()) { if (String.Compare(name, presence.ControllingClient.Name, true) == 0) { avatar = presence; break; } } return (avatar != null); } /// <summary> /// Get a scene object group that contains the prim with the given local id /// </summary> /// <param name="localID"></param> /// <returns>null if no scene object group containing that prim is found</returns> public SceneObjectGroup GetGroupByPrim(uint localID) { EntityBase entity; if (Entities.TryGetValue(localID, out entity)) return entity as SceneObjectGroup; // m_log.DebugFormat("[SCENE GRAPH]: Entered GetGroupByPrim with localID {0}", localID); SceneObjectGroup sog; lock (SceneObjectGroupsByLocalPartID) SceneObjectGroupsByLocalPartID.TryGetValue(localID, out sog); if (sog != null) { if (sog.ContainsPart(localID)) { // m_log.DebugFormat( // "[SCENE GRAPH]: Found scene object {0} {1} {2} containing part with local id {3} in {4}. Returning.", // sog.Name, sog.UUID, sog.LocalId, localID, m_parentScene.RegionInfo.RegionName); return sog; } else { lock (SceneObjectGroupsByLocalPartID) { m_log.WarnFormat( "[SCENE GRAPH]: Found scene object {0} {1} {2} via SceneObjectGroupsByLocalPartID index but it doesn't contain part with local id {3}. Removing from entry from index in {4}.", sog.Name, sog.UUID, sog.LocalId, localID, m_parentScene.RegionInfo.RegionName); m_log.WarnFormat("stack: {0}", Environment.StackTrace); SceneObjectGroupsByLocalPartID.Remove(localID); } } } EntityBase[] entityList = GetEntities(); foreach (EntityBase ent in entityList) { //m_log.DebugFormat("Looking at entity {0}", ent.UUID); if (ent is SceneObjectGroup) { sog = (SceneObjectGroup)ent; if (sog.ContainsPart(localID)) { lock (SceneObjectGroupsByLocalPartID) SceneObjectGroupsByLocalPartID[localID] = sog; return sog; } } } return null; } /// <summary> /// Get a scene object group that contains the prim with the given uuid /// </summary> /// <param name="fullID"></param> /// <returns>null if no scene object group containing that prim is found</returns> public SceneObjectGroup GetGroupByPrim(UUID fullID) { SceneObjectGroup sog; lock (SceneObjectGroupsByFullPartID) SceneObjectGroupsByFullPartID.TryGetValue(fullID, out sog); if (sog != null) { if (sog.ContainsPart(fullID)) return sog; lock (SceneObjectGroupsByFullPartID) SceneObjectGroupsByFullPartID.Remove(fullID); } EntityBase[] entityList = GetEntities(); foreach (EntityBase ent in entityList) { if (ent is SceneObjectGroup) { sog = (SceneObjectGroup)ent; if (sog.ContainsPart(fullID)) { lock (SceneObjectGroupsByFullPartID) SceneObjectGroupsByFullPartID[fullID] = sog; return sog; } } } return null; } protected internal EntityIntersection GetClosestIntersectingPrim(Ray hray, bool frontFacesOnly, bool faceCenters) { // Primitive Ray Tracing float closestDistance = 280f; EntityIntersection result = new EntityIntersection(); EntityBase[] EntityList = GetEntities(); foreach (EntityBase ent in EntityList) { if (ent is SceneObjectGroup) { SceneObjectGroup reportingG = (SceneObjectGroup)ent; EntityIntersection inter = reportingG.TestIntersection(hray, frontFacesOnly, faceCenters); if (inter.HitTF && inter.distance < closestDistance) { closestDistance = inter.distance; result = inter; } } } return result; } /// <summary> /// Get all the scene object groups. /// </summary> /// <returns> /// The scene object groups. If the scene is empty then an empty list is returned. /// </returns> protected internal List<SceneObjectGroup> GetSceneObjectGroups() { lock (SceneObjectGroupsByFullID) return new List<SceneObjectGroup>(SceneObjectGroupsByFullID.Values); } /// <summary> /// Get a group in the scene /// </summary> /// <param name="fullID">UUID of the group</param> /// <returns>null if no such group was found</returns> protected internal SceneObjectGroup GetSceneObjectGroup(UUID fullID) { lock (SceneObjectGroupsByFullID) { if (SceneObjectGroupsByFullID.ContainsKey(fullID)) return SceneObjectGroupsByFullID[fullID]; } return null; } /// <summary> /// Get a group in the scene /// </summary> /// <remarks> /// This will only return a group if the local ID matches the root part, not other parts. /// </remarks> /// <param name="localID">Local id of the root part of the group</param> /// <returns>null if no such group was found</returns> protected internal SceneObjectGroup GetSceneObjectGroup(uint localID) { lock (SceneObjectGroupsByLocalPartID) { if (SceneObjectGroupsByLocalPartID.ContainsKey(localID)) { SceneObjectGroup so = SceneObjectGroupsByLocalPartID[localID]; if (so.LocalId == localID) return so; } } return null; } /// <summary> /// Get a group by name from the scene (will return the first /// found, if there are more than one prim with the same name) /// </summary> /// <param name="name"></param> /// <returns>null if the part was not found</returns> protected internal SceneObjectGroup GetSceneObjectGroup(string name) { SceneObjectGroup so = null; Entities.Find( delegate(EntityBase entity) { if (entity is SceneObjectGroup) { if (entity.Name == name) { so = (SceneObjectGroup)entity; return true; } } return false; } ); return so; } /// <summary> /// Get a part contained in this scene. /// </summary> /// <param name="localID"></param> /// <returns>null if the part was not found</returns> protected internal SceneObjectPart GetSceneObjectPart(uint localID) { SceneObjectGroup group = GetGroupByPrim(localID); if (group == null || group.IsDeleted) return null; return group.GetPart(localID); } /// <summary> /// Get a prim by name from the scene (will return the first /// found, if there are more than one prim with the same name) /// </summary> /// <param name="name"></param> /// <returns>null if the part was not found</returns> protected internal SceneObjectPart GetSceneObjectPart(string name) { SceneObjectPart sop = null; Entities.Find( delegate(EntityBase entity) { if (entity is SceneObjectGroup) { foreach (SceneObjectPart p in ((SceneObjectGroup)entity).Parts) { // m_log.DebugFormat("[SCENE GRAPH]: Part {0} has name {1}", p.UUID, p.Name); if (p.Name == name) { sop = p; return true; } } } return false; } ); return sop; } /// <summary> /// Get a part contained in this scene. /// </summary> /// <param name="fullID"></param> /// <returns>null if the part was not found</returns> protected internal SceneObjectPart GetSceneObjectPart(UUID fullID) { SceneObjectGroup group = GetGroupByPrim(fullID); if (group == null) return null; return group.GetPart(fullID); } /// <summary> /// Returns a list of the entities in the scene. This is a new list so no locking is required to iterate over /// it /// </summary> /// <returns></returns> protected internal EntityBase[] GetEntities() { return Entities.GetEntities(); } #endregion #region Other Methods protected internal void physicsBasedCrash() { handlerPhysicsCrash = UnRecoverableError; if (handlerPhysicsCrash != null) { handlerPhysicsCrash(); } } protected internal UUID ConvertLocalIDToFullID(uint localID) { SceneObjectGroup group = GetGroupByPrim(localID); if (group != null) return group.GetPartsFullID(localID); else return UUID.Zero; } /// <summary> /// Performs action once on all scene object groups. /// </summary> /// <param name="action"></param> protected internal void ForEachSOG(Action<SceneObjectGroup> action) { foreach (SceneObjectGroup obj in GetSceneObjectGroups()) { try { action(obj); } catch (Exception e) { // Catch it and move on. This includes situations where objlist has inconsistent info m_log.WarnFormat( "[SCENEGRAPH]: Problem processing action in ForEachSOG: {0} {1}", e.Message, e.StackTrace); } } } /// <summary> /// Performs action on all ROOT (not child) scene presences. /// This is just a shortcut function since frequently actions only appy to root SPs /// </summary> /// <param name="action"></param> public void ForEachAvatar(Action<ScenePresence> action) { ForEachScenePresence(delegate(ScenePresence sp) { if (!sp.IsChildAgent) action(sp); }); } /// <summary> /// Performs action on all scene presences. This can ultimately run the actions in parallel but /// any delegates passed in will need to implement their own locking on data they reference and /// modify outside of the scope of the delegate. /// </summary> /// <param name="action"></param> public void ForEachScenePresence(Action<ScenePresence> action) { // Once all callers have their delegates configured for parallelism, we can unleash this /* Action<ScenePresence> protectedAction = new Action<ScenePresence>(delegate(ScenePresence sp) { try { action(sp); } catch (Exception e) { m_log.Info("[SCENEGRAPH]: Error in " + m_parentScene.RegionInfo.RegionName + ": " + e.ToString()); m_log.Info("[SCENEGRAPH]: Stack Trace: " + e.StackTrace); } }); Parallel.ForEach<ScenePresence>(GetScenePresences(), protectedAction); */ // For now, perform actions serially List<ScenePresence> presences = GetScenePresences(); foreach (ScenePresence sp in presences) { try { action(sp); } catch (Exception e) { m_log.Error("[SCENEGRAPH]: Error in " + m_parentScene.RegionInfo.RegionName + ": " + e.ToString()); } } } #endregion #region Client Event handlers protected internal void ClientChangeObject(uint localID, object odata, IClientAPI remoteClient) { SceneObjectPart part = GetSceneObjectPart(localID); ObjectChangeData data = (ObjectChangeData)odata; if (part != null) { SceneObjectGroup grp = part.ParentGroup; if (grp != null) { if (m_parentScene.Permissions.CanEditObject(grp.UUID, remoteClient.AgentId)) { // These two are exceptions SL makes in the interpretation // of the change flags. Must check them here because otherwise // the group flag (see below) would be lost if (data.change == ObjectChangeType.groupS) data.change = ObjectChangeType.primS; if (data.change == ObjectChangeType.groupPS) data.change = ObjectChangeType.primPS; part.StoreUndoState(data.change); // lets test only saving what we changed grp.doChangeObject(part, (ObjectChangeData)data); } else { // Is this any kind of group operation? if ((data.change & ObjectChangeType.Group) != 0) { // Is a move and/or rotation requested? if ((data.change & (ObjectChangeType.Position | ObjectChangeType.Rotation)) != 0) { // Are we allowed to move it? if (m_parentScene.Permissions.CanMoveObject(grp.UUID, remoteClient.AgentId)) { // Strip all but move and rotation from request data.change &= (ObjectChangeType.Group | ObjectChangeType.Position | ObjectChangeType.Rotation); part.StoreUndoState(data.change); grp.doChangeObject(part, (ObjectChangeData)data); } } } } } } } /// <summary> /// Update the scale of an individual prim. /// </summary> /// <param name="localID"></param> /// <param name="scale"></param> /// <param name="remoteClient"></param> protected internal void UpdatePrimScale(uint localID, Vector3 scale, IClientAPI remoteClient) { SceneObjectPart part = GetSceneObjectPart(localID); if (part != null) { if (m_parentScene.Permissions.CanEditObject(part.ParentGroup.UUID, remoteClient.AgentId)) { bool physbuild = false; if (part.ParentGroup.RootPart.PhysActor != null) { part.ParentGroup.RootPart.PhysActor.Building = true; physbuild = true; } part.Resize(scale); if (physbuild) part.ParentGroup.RootPart.PhysActor.Building = false; } } } protected internal void UpdatePrimGroupScale(uint localID, Vector3 scale, IClientAPI remoteClient) { SceneObjectGroup group = GetGroupByPrim(localID); if (group != null) { if (m_parentScene.Permissions.CanEditObject(group.UUID, remoteClient.AgentId)) { bool physbuild = false; if (group.RootPart.PhysActor != null) { group.RootPart.PhysActor.Building = true; physbuild = true; } group.GroupResize(scale); if (physbuild) group.RootPart.PhysActor.Building = false; } } } /// <summary> /// This handles the nifty little tool tip that you get when you drag your mouse over an object /// Send to the Object Group to process. We don't know enough to service the request /// </summary> /// <param name="remoteClient"></param> /// <param name="AgentID"></param> /// <param name="RequestFlags"></param> /// <param name="ObjectID"></param> protected internal void RequestObjectPropertiesFamily( IClientAPI remoteClient, UUID AgentID, uint RequestFlags, UUID ObjectID) { SceneObjectGroup group = GetGroupByPrim(ObjectID); if (group != null) { group.ServiceObjectPropertiesFamilyRequest(remoteClient, AgentID, RequestFlags); } } /// <summary> /// /// </summary> /// <param name="localID"></param> /// <param name="rot"></param> /// <param name="remoteClient"></param> protected internal void UpdatePrimSingleRotation(uint localID, Quaternion rot, IClientAPI remoteClient) { SceneObjectGroup group = GetGroupByPrim(localID); if (group != null) { if (m_parentScene.Permissions.CanMoveObject(group.UUID, remoteClient.AgentId)) { group.UpdateSingleRotation(rot, localID); } } } /// <summary> /// /// </summary> /// <param name="localID"></param> /// <param name="rot"></param> /// <param name="remoteClient"></param> protected internal void UpdatePrimSingleRotationPosition(uint localID, Quaternion rot, Vector3 pos, IClientAPI remoteClient) { SceneObjectGroup group = GetGroupByPrim(localID); if (group != null) { if (m_parentScene.Permissions.CanMoveObject(group.UUID, remoteClient.AgentId)) { group.UpdateSingleRotation(rot, pos, localID); } } } /// <summary> /// Update the rotation of a whole group. /// </summary> /// <param name="localID"></param> /// <param name="rot"></param> /// <param name="remoteClient"></param> protected internal void UpdatePrimGroupRotation(uint localID, Quaternion rot, IClientAPI remoteClient) { SceneObjectGroup group = GetGroupByPrim(localID); if (group != null) { if (m_parentScene.Permissions.CanMoveObject(group.UUID, remoteClient.AgentId)) { group.UpdateGroupRotationR(rot); } } } /// <summary> /// /// </summary> /// <param name="localID"></param> /// <param name="pos"></param> /// <param name="rot"></param> /// <param name="remoteClient"></param> protected internal void UpdatePrimGroupRotation(uint localID, Vector3 pos, Quaternion rot, IClientAPI remoteClient) { SceneObjectGroup group = GetGroupByPrim(localID); if (group != null) { if (m_parentScene.Permissions.CanMoveObject(group.UUID, remoteClient.AgentId)) { group.UpdateGroupRotationPR(pos, rot); } } } /// <summary> /// Update the position of the given part /// </summary> /// <param name="localID"></param> /// <param name="pos"></param> /// <param name="remoteClient"></param> protected internal void UpdatePrimSinglePosition(uint localID, Vector3 pos, IClientAPI remoteClient) { SceneObjectGroup group = GetGroupByPrim(localID); if (group != null) { if (m_parentScene.Permissions.CanMoveObject(group.UUID, remoteClient.AgentId) || group.IsAttachment) { group.UpdateSinglePosition(pos, localID); } } } /// <summary> /// Update the position of the given group. /// </summary> /// <param name="localId"></param> /// <param name="pos"></param> /// <param name="remoteClient"></param> public void UpdatePrimGroupPosition(uint localId, Vector3 pos, IClientAPI remoteClient) { UpdatePrimGroupPosition(localId, pos, remoteClient.AgentId); } /// <summary> /// Update the position of the given group. /// </summary> /// <param name="localId"></param> /// <param name="pos"></param> /// <param name="updatingAgentId"></param> public void UpdatePrimGroupPosition(uint localId, Vector3 pos, UUID updatingAgentId) { SceneObjectGroup group = GetGroupByPrim(localId); if (group != null) { if (group.IsAttachment || (group.RootPart.Shape.PCode == 9 && group.RootPart.Shape.State != 0)) { // Set the new attachment point data in the object byte attachmentPoint = group.GetAttachmentPoint(); group.UpdateGroupPosition(pos); group.IsAttachment = false; group.AbsolutePosition = group.RootPart.AttachedPos; group.AttachmentPoint = attachmentPoint; group.HasGroupChanged = true; } else { if (m_parentScene.Permissions.CanMoveObject(group.UUID, updatingAgentId) && m_parentScene.Permissions.CanObjectEntry(group.UUID, false, pos)) { group.UpdateGroupPosition(pos); } } } } /// <summary> /// Update the texture entry of the given prim. /// </summary> /// <remarks> /// A texture entry is an object that contains details of all the textures of the prim's face. In this case, /// the texture is given in its byte serialized form. /// </remarks> /// <param name="localID"></param> /// <param name="texture"></param> /// <param name="remoteClient"></param> protected internal void UpdatePrimTexture(uint localID, byte[] texture, IClientAPI remoteClient) { SceneObjectGroup group = GetGroupByPrim(localID); if (group != null) { if (m_parentScene.Permissions.CanEditObject(group.UUID,remoteClient.AgentId)) { group.UpdateTextureEntry(localID, texture); } } } /// <summary> /// Update the flags on a scene object. This covers properties such as phantom, physics and temporary. /// </summary> /// <remarks> /// This is currently handling the incoming call from the client stack (e.g. LLClientView). /// </remarks> /// <param name="localID"></param> /// <param name="UsePhysics"></param> /// <param name="SetTemporary"></param> /// <param name="SetPhantom"></param> /// <param name="remoteClient"></param> protected internal void UpdatePrimFlags( uint localID, bool UsePhysics, bool SetTemporary, bool SetPhantom, ExtraPhysicsData PhysData, IClientAPI remoteClient) { SceneObjectGroup group = GetGroupByPrim(localID); if (group != null) { if (m_parentScene.Permissions.CanEditObject(group.UUID, remoteClient.AgentId)) { // VolumeDetect can't be set via UI and will always be off when a change is made there // now only change volume dtc if phantom off bool wantedPhys = UsePhysics; if (PhysData.PhysShapeType == PhysShapeType.invalid) // check for extraPhysics data { bool vdtc; if (SetPhantom) // if phantom keep volumedtc vdtc = group.RootPart.VolumeDetectActive; else // else turn it off vdtc = false; group.UpdatePrimFlags(localID, UsePhysics, SetTemporary, SetPhantom, vdtc); } else { SceneObjectPart part = GetSceneObjectPart(localID); if (part != null) { part.UpdateExtraPhysics(PhysData); if (remoteClient != null) remoteClient.SendPartPhysicsProprieties(part); } } if (wantedPhys != group.UsesPhysics && remoteClient != null) { remoteClient.SendAlertMessage("Object physics canceled because exceeds the limit of " + m_parentScene.m_linksetPhysCapacity + " physical prims with shape type not set to None"); group.RootPart.ScheduleFullUpdate(); } } } } /// <summary> /// /// </summary> /// <param name="primLocalID"></param> /// <param name="description"></param> protected internal void PrimName(IClientAPI remoteClient, uint primLocalID, string name) { SceneObjectGroup group = GetGroupByPrim(primLocalID); if (group != null) { if (m_parentScene.Permissions.CanEditObject(group.UUID, remoteClient.AgentId)) { group.SetPartName(Util.CleanString(name), primLocalID); group.HasGroupChanged = true; } } } /// <summary> /// Handle a prim description set request from a viewer. /// </summary> /// <param name="primLocalID"></param> /// <param name="description"></param> protected internal void PrimDescription(IClientAPI remoteClient, uint primLocalID, string description) { SceneObjectGroup group = GetGroupByPrim(primLocalID); if (group != null) { if (m_parentScene.Permissions.CanEditObject(group.UUID, remoteClient.AgentId)) { group.SetPartDescription(Util.CleanString(description), primLocalID); group.HasGroupChanged = true; } } } /// <summary> /// Set a click action for the prim. /// </summary> /// <param name="remoteClient"></param> /// <param name="primLocalID"></param> /// <param name="clickAction"></param> protected internal void PrimClickAction(IClientAPI remoteClient, uint primLocalID, string clickAction) { // m_log.DebugFormat( // "[SCENEGRAPH]: User {0} set click action for {1} to {2}", remoteClient.Name, primLocalID, clickAction); SceneObjectGroup group = GetGroupByPrim(primLocalID); if (group != null) { if (m_parentScene.Permissions.CanEditObject(group.UUID, remoteClient.AgentId)) { SceneObjectPart part = m_parentScene.GetSceneObjectPart(primLocalID); if (part != null) { part.ClickAction = Convert.ToByte(clickAction); group.HasGroupChanged = true; } } } } protected internal void PrimMaterial(IClientAPI remoteClient, uint primLocalID, string material) { SceneObjectGroup group = GetGroupByPrim(primLocalID); if (group != null) { if (m_parentScene.Permissions.CanEditObject(group.UUID, remoteClient.AgentId)) { SceneObjectPart part = m_parentScene.GetSceneObjectPart(primLocalID); if (part != null) { part.Material = Convert.ToByte(material); group.HasGroupChanged = true; remoteClient.SendPartPhysicsProprieties(part); } } } } protected internal void UpdateExtraParam(UUID agentID, uint primLocalID, ushort type, bool inUse, byte[] data) { SceneObjectGroup group = GetGroupByPrim(primLocalID); if (group != null) { if (m_parentScene.Permissions.CanEditObject(group.UUID, agentID)) { group.UpdateExtraParam(primLocalID, type, inUse, data); } } } /// <summary> /// /// </summary> /// <param name="primLocalID"></param> /// <param name="shapeBlock"></param> protected internal void UpdatePrimShape(UUID agentID, uint primLocalID, UpdateShapeArgs shapeBlock) { SceneObjectGroup group = GetGroupByPrim(primLocalID); if (group != null) { if (m_parentScene.Permissions.CanEditObject(group.UUID, agentID)) { ObjectShapePacket.ObjectDataBlock shapeData = new ObjectShapePacket.ObjectDataBlock(); shapeData.ObjectLocalID = shapeBlock.ObjectLocalID; shapeData.PathBegin = shapeBlock.PathBegin; shapeData.PathCurve = shapeBlock.PathCurve; shapeData.PathEnd = shapeBlock.PathEnd; shapeData.PathRadiusOffset = shapeBlock.PathRadiusOffset; shapeData.PathRevolutions = shapeBlock.PathRevolutions; shapeData.PathScaleX = shapeBlock.PathScaleX; shapeData.PathScaleY = shapeBlock.PathScaleY; shapeData.PathShearX = shapeBlock.PathShearX; shapeData.PathShearY = shapeBlock.PathShearY; shapeData.PathSkew = shapeBlock.PathSkew; shapeData.PathTaperX = shapeBlock.PathTaperX; shapeData.PathTaperY = shapeBlock.PathTaperY; shapeData.PathTwist = shapeBlock.PathTwist; shapeData.PathTwistBegin = shapeBlock.PathTwistBegin; shapeData.ProfileBegin = shapeBlock.ProfileBegin; shapeData.ProfileCurve = shapeBlock.ProfileCurve; shapeData.ProfileEnd = shapeBlock.ProfileEnd; shapeData.ProfileHollow = shapeBlock.ProfileHollow; group.UpdateShape(shapeData, primLocalID); } } } /// <summary> /// Initial method invoked when we receive a link objects request from the client. /// </summary> /// <param name="client"></param> /// <param name="parentPrim"></param> /// <param name="childPrims"></param> protected internal void LinkObjects(SceneObjectPart root, List<SceneObjectPart> children) { if (root.KeyframeMotion != null) { root.KeyframeMotion.Stop(); root.KeyframeMotion = null; } SceneObjectGroup parentGroup = root.ParentGroup; if (parentGroup == null) return; // Cowardly refuse to link to a group owned root if (parentGroup.OwnerID == parentGroup.GroupID) return; Monitor.Enter(m_updateLock); try { List<SceneObjectGroup> childGroups = new List<SceneObjectGroup>(); // We do this in reverse to get the link order of the prims correct for (int i = 0; i < children.Count; i++) { SceneObjectGroup child = children[i].ParentGroup; // Don't try and add a group to itself - this will only cause severe problems later on. if (child == parentGroup) continue; // Make sure no child prim is set for sale // So that, on delink, no prims are unwittingly // left for sale and sold off if (child != null) { child.RootPart.ObjectSaleType = 0; child.RootPart.SalePrice = 10; childGroups.Add(child); } } foreach (SceneObjectGroup child in childGroups) { if (parentGroup.OwnerID == child.OwnerID) { parentGroup.LinkToGroup(child); child.DetachFromBackup(); // this is here so physics gets updated! // Don't remove! Bad juju! Stay away! or fix physics! // already done in LinkToGroup // child.AbsolutePosition = child.AbsolutePosition; } } // We need to explicitly resend the newly link prim's object properties since no other actions // occur on link to invoke this elsewhere (such as object selection) if (childGroups.Count > 0) { parentGroup.RootPart.CreateSelected = true; parentGroup.TriggerScriptChangedEvent(Changed.LINK); parentGroup.HasGroupChanged = true; parentGroup.ScheduleGroupForFullUpdate(); } } finally { /* lock (SceneObjectGroupsByLocalPartID) { foreach (SceneObjectPart part in parentGroup.Parts) SceneObjectGroupsByLocalPartID[part.LocalId] = parentGroup; } */ parentGroup.AdjustChildPrimPermissions(false); parentGroup.HasGroupChanged = true; parentGroup.ProcessBackup(m_parentScene.SimulationDataService, true); parentGroup.ScheduleGroupForFullUpdate(); Monitor.Exit(m_updateLock); } } /// <summary> /// Delink a linkset /// </summary> /// <param name="prims"></param> protected internal void DelinkObjects(List<SceneObjectPart> prims) { Monitor.Enter(m_updateLock); try { List<SceneObjectPart> childParts = new List<SceneObjectPart>(); List<SceneObjectPart> rootParts = new List<SceneObjectPart>(); List<SceneObjectGroup> affectedGroups = new List<SceneObjectGroup>(); // Look them all up in one go, since that is comparatively expensive // foreach (SceneObjectPart part in prims) { if(part == null) continue; SceneObjectGroup parentSOG = part.ParentGroup; if(parentSOG == null || parentSOG.IsDeleted || parentSOG.inTransit || parentSOG.PrimCount == 1) continue; if (!affectedGroups.Contains(parentSOG)) { affectedGroups.Add(parentSOG); if(parentSOG.RootPart.PhysActor != null) parentSOG.RootPart.PhysActor.Building = true; } if (part.KeyframeMotion != null) { part.KeyframeMotion.Stop(); part.KeyframeMotion = null; } if (part.LinkNum < 2) // Root { rootParts.Add(part); } else { part.LastOwnerID = part.ParentGroup.RootPart.LastOwnerID; part.RezzerID = part.ParentGroup.RootPart.RezzerID; childParts.Add(part); } } if (childParts.Count > 0) { foreach (SceneObjectPart child in childParts) { // Unlink all child parts from their groups child.ParentGroup.DelinkFromGroup(child, true); //child.ParentGroup is now other child.ParentGroup.HasGroupChanged = true; child.ParentGroup.ScheduleGroupForFullUpdate(); } } foreach (SceneObjectPart root in rootParts) { // In most cases, this will run only one time, and the prim // will be a solo prim // However, editing linked parts and unlinking may be different // SceneObjectGroup group = root.ParentGroup; List<SceneObjectPart> newSet = new List<SceneObjectPart>(group.Parts); newSet.Remove(root); int numChildren = newSet.Count; if(numChildren == 0) break; foreach (SceneObjectPart p in newSet) group.DelinkFromGroup(p, false); SceneObjectPart newRoot = newSet[0]; // If there is more than one prim remaining, we // need to re-link // if (numChildren > 1) { // Determine new root // newSet.RemoveAt(0); foreach (SceneObjectPart newChild in newSet) newChild.ClearUpdateSchedule(); LinkObjects(newRoot, newSet); } else { newRoot.TriggerScriptChangedEvent(Changed.LINK); newRoot.ParentGroup.HasGroupChanged = true; newRoot.ParentGroup.ScheduleGroupForFullUpdate(); } } // trigger events in the roots // foreach (SceneObjectGroup g in affectedGroups) { if(g.RootPart.PhysActor != null) g.RootPart.PhysActor.Building = false; g.AdjustChildPrimPermissions(false); // Child prims that have been unlinked and deleted will // return unless the root is deleted. This will remove them // from the database. They will be rewritten immediately, // minus the rows for the unlinked child prims. m_parentScene.SimulationDataService.RemoveObject(g.UUID, m_parentScene.RegionInfo.RegionID); g.TriggerScriptChangedEvent(Changed.LINK); g.HasGroupChanged = true; // Persist g.ScheduleGroupForFullUpdate(); } } finally { Monitor.Exit(m_updateLock); } } protected internal void MakeObjectSearchable(IClientAPI remoteClient, bool IncludeInSearch, uint localID) { UUID user = remoteClient.AgentId; UUID objid = UUID.Zero; SceneObjectPart obj = null; EntityBase[] entityList = GetEntities(); foreach (EntityBase ent in entityList) { if (ent is SceneObjectGroup) { SceneObjectGroup sog = ent as SceneObjectGroup; foreach (SceneObjectPart part in sog.Parts) { if (part.LocalId == localID) { objid = part.UUID; obj = part; } } } } //Protip: In my day, we didn't call them searchable objects, we called them limited point-to-point joints //aka ObjectFlags.JointWheel = IncludeInSearch //Permissions model: Object can be REMOVED from search IFF: // * User owns object //use CanEditObject //Object can be ADDED to search IFF: // * User owns object // * Asset/DRM permission bit "modify" is enabled //use CanEditObjectPosition // libomv will complain about PrimFlags.JointWheel being // deprecated, so we #pragma warning disable 0612 if (IncludeInSearch && m_parentScene.Permissions.CanEditObject(objid, user)) { obj.ParentGroup.RootPart.AddFlag(PrimFlags.JointWheel); obj.ParentGroup.HasGroupChanged = true; } else if (!IncludeInSearch && m_parentScene.Permissions.CanMoveObject(objid,user)) { obj.ParentGroup.RootPart.RemFlag(PrimFlags.JointWheel); obj.ParentGroup.HasGroupChanged = true; } #pragma warning restore 0612 } /// <summary> /// Duplicate the given object. /// </summary> /// <param name="originalPrim"></param> /// <param name="offset"></param> /// <param name="flags"></param> /// <param name="AgentID"></param> /// <param name="GroupID"></param> /// <param name="rot"></param> /// <returns>null if duplication fails, otherwise the duplicated object</returns> /// <summary> public SceneObjectGroup DuplicateObject(uint originalPrimID, Vector3 offset, uint flags, UUID AgentID, UUID GroupID, Quaternion rot) { // m_log.DebugFormat( // "[SCENE]: Duplication of object {0} at offset {1} requested by agent {2}", // originalPrimID, offset, AgentID); SceneObjectGroup original = GetGroupByPrim(originalPrimID); if (original != null) { if (m_parentScene.Permissions.CanDuplicateObject( original.PrimCount, original.UUID, AgentID, original.AbsolutePosition)) { SceneObjectGroup copy = original.Copy(true); copy.AbsolutePosition = copy.AbsolutePosition + offset; if (original.OwnerID != AgentID) { copy.SetOwnerId(AgentID); copy.SetRootPartOwner(copy.RootPart, AgentID, GroupID); SceneObjectPart[] partList = copy.Parts; if (m_parentScene.Permissions.PropagatePermissions()) { foreach (SceneObjectPart child in partList) { child.Inventory.ChangeInventoryOwner(AgentID); child.TriggerScriptChangedEvent(Changed.OWNER); child.ApplyNextOwnerPermissions(); } } } // FIXME: This section needs to be refactored so that it just calls AddSceneObject() Entities.Add(copy); lock (SceneObjectGroupsByFullID) SceneObjectGroupsByFullID[copy.UUID] = copy; SceneObjectPart[] parts = copy.Parts; m_numTotalPrim += parts.Length; foreach (SceneObjectPart part in parts) { if (part.GetPrimType() == PrimType.SCULPT) m_numMesh++; else m_numPrim++; lock (SceneObjectGroupsByFullPartID) SceneObjectGroupsByFullPartID[part.UUID] = copy; lock (SceneObjectGroupsByLocalPartID) SceneObjectGroupsByLocalPartID[part.LocalId] = copy; } // PROBABLE END OF FIXME // Since we copy from a source group that is in selected // state, but the copy is shown deselected in the viewer, // We need to clear the selection flag here, else that // prim never gets persisted at all. The client doesn't // think it's selected, so it will never send a deselect... copy.IsSelected = false; m_numPrim += copy.Parts.Length; if (rot != Quaternion.Identity) { copy.UpdateGroupRotationR(rot); } copy.CreateScriptInstances(0, false, m_parentScene.DefaultScriptEngine, 1); copy.HasGroupChanged = true; copy.ScheduleGroupForFullUpdate(); copy.ResumeScripts(); // required for physics to update it's position copy.AbsolutePosition = copy.AbsolutePosition; return copy; } } else { m_log.WarnFormat("[SCENE]: Attempted to duplicate nonexistant prim id {0}", GroupID); } return null; } /// Calculates the distance between two Vector3s /// </summary> /// <param name="v1"></param> /// <param name="v2"></param> /// <returns></returns> protected internal float Vector3Distance(Vector3 v1, Vector3 v2) { // We don't really need the double floating point precision... // so casting it to a single return (float) Math.Sqrt((v1.X - v2.X) * (v1.X - v2.X) + (v1.Y - v2.Y) * (v1.Y - v2.Y) + (v1.Z - v2.Z) * (v1.Z - v2.Z)); } #endregion } }