16 files changed, 1397 insertions, 381 deletions

diff --git a/OpenSim/Region/Framework/Scenes/Animation/AnimationSet.cs b/OpenSim/Region/Framework/Scenes/Animation/AnimationSet.cs
index ad421ee..3d8e8be 100644
--- a/OpenSim/Region/Framework/Scenes/Animation/AnimationSet.cs
+++ b/OpenSim/Region/Framework/Scenes/Animation/AnimationSet.cs
@@ -41,12 +41,13 @@ namespace OpenSim.Region.Framework.Scenes.Animation
     {
 //        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
 
+        private OpenSim.Framework.Animation m_implicitDefaultAnimation = new OpenSim.Framework.Animation();
         private OpenSim.Framework.Animation m_defaultAnimation = new OpenSim.Framework.Animation();
         private List<OpenSim.Framework.Animation> m_animations = new List<OpenSim.Framework.Animation>();
 
-        public OpenSim.Framework.Animation DefaultAnimation 
+        public OpenSim.Framework.Animation ImplicitDefaultAnimation 
         {
-            get { return m_defaultAnimation; } 
+            get { return m_implicitDefaultAnimation; } 
         }
         
         public AnimationSet()
@@ -119,6 +120,7 @@ namespace OpenSim.Region.Framework.Scenes.Animation
             if (m_defaultAnimation.AnimID != animID)
             {
                 m_defaultAnimation = new OpenSim.Framework.Animation(animID, sequenceNum, objectID);
+                m_implicitDefaultAnimation = m_defaultAnimation;
                 return true;
             }
             return false;
diff --git a/OpenSim/Region/Framework/Scenes/EventManager.cs b/OpenSim/Region/Framework/Scenes/EventManager.cs
index eee5960..e2414eb 100644
--- a/OpenSim/Region/Framework/Scenes/EventManager.cs
+++ b/OpenSim/Region/Framework/Scenes/EventManager.cs
@@ -47,30 +47,75 @@ namespace OpenSim.Region.Framework.Scenes
         
         public delegate void OnFrameDelegate();
 
+        /// <summary>
+        /// Triggered on each sim frame.
+        /// </summary>
+        /// <remarks>
+        /// This gets triggered in <see cref="OpenSim.Region.Framework.Scenes.Scene.Update"/>
+        /// Core uses it for things like Sun, Wind & Clouds
+        /// The MRM module also uses it.
+        /// </remarks>
         public event OnFrameDelegate OnFrame;
 
         public delegate void ClientMovement(ScenePresence client);
 
+        /// <summary>
+        /// Trigerred when an agent moves.
+        /// </summary>
+        /// <remarks>
+        /// This gets triggered in <see cref="OpenSim.Region.Framework.Scenes.ScenePresence.HandleAgentUpdate"/>
+        /// prior to <see cref="OpenSim.Region.Framework.Scenes.ScenePresence.TriggerScenePresenceUpdated"/>
+        /// </remarks>
         public event ClientMovement OnClientMovement;
 
         public delegate void OnTerrainTaintedDelegate();
 
+        /// <summary>
+        /// Triggered if the terrain has been edited
+        /// </summary>
+        /// <remarks>
+        /// This gets triggered in <see cref="OpenSim.Region.CoreModules.World.Terrain.CheckForTerrainUpdates"/>
+        /// after it determines that an update has been made.
+        /// </remarks>
         public event OnTerrainTaintedDelegate OnTerrainTainted;
 
         public delegate void OnTerrainTickDelegate();
 
-        public delegate void OnTerrainUpdateDelegate();
-
+        /// <summary>
+        /// Triggered if the terrain has been edited
+        /// </summary>
+        /// <remarks>
+        /// This gets triggered in <see cref="OpenSim.Region.Framework.Scenes.Scene.UpdateTerrain"/>
+        /// but is used by core solely to update the physics engine.
+        /// </remarks>
         public event OnTerrainTickDelegate OnTerrainTick;
 
+        public delegate void OnTerrainUpdateDelegate();
+
         public event OnTerrainUpdateDelegate OnTerrainUpdate;
 
         public delegate void OnBackupDelegate(ISimulationDataService datastore, bool forceBackup);
 
+        /// <summary>
+        /// Triggered when a region is backed up/persisted to storage
+        /// </summary>
+        /// <remarks>
+        /// This gets triggered in <see cref="OpenSim.Region.Framework.Scenes.Scene.Backup"/>
+        /// and is fired before the persistence occurs.
+        /// </remarks>
         public event OnBackupDelegate OnBackup;
 
         public delegate void OnClientConnectCoreDelegate(IClientCore client);
 
+        /// <summary>
+        /// Triggered when a new client connects to the scene.
+        /// </summary>
+        /// <remarks>
+        /// This gets triggered in <see cref="TriggerOnNewClient"/>,
+        /// which checks if an instance of <see cref="OpenSim.Framework.IClientAPI"/>
+        /// also implements <see cref="OpenSim.Framework.Client.IClientCore"/> and as such,
+        /// is not triggered by <see cref="OpenSim.Region.OptionalModules.World.NPC">NPCs</see>.
+        /// </remarks>
         public event OnClientConnectCoreDelegate OnClientConnect;
 
         public delegate void OnNewClientDelegate(IClientAPI client);
@@ -80,33 +125,96 @@ namespace OpenSim.Region.Framework.Scenes
         /// </summary>
         /// <remarks>
         /// This is triggered for both child and root agent client connections.
+        ///
         /// Triggered before OnClientLogin.
+        ///
+        /// This is triggered under per-agent lock.  So if you want to perform any long-running operations, please
+        /// do this on a separate thread.
         /// </remarks>
         public event OnNewClientDelegate OnNewClient;
 
         /// <summary>
         /// Fired if the client entering this sim is doing so as a new login
         /// </summary>
+        /// <remarks>
+        /// This is triggered under per-agent lock.  So if you want to perform any long-running operations, please
+        /// do this on a separate thread.
+        /// </remarks>
         public event Action<IClientAPI> OnClientLogin;
 
         public delegate void OnNewPresenceDelegate(ScenePresence presence);
 
+        /// <summary>
+        /// Triggered when a new presence is added to the scene
+        /// </summary>
+        /// <remarks>
+        /// Triggered in <see cref="OpenSim.Region.Framework.Scenes.Scene.AddNewClient"/> which is used by both
+        /// <see cref="OpenSim.Framework.PresenceType.User">users</see> and <see cref="OpenSim.Framework.PresenceType.Npc">NPCs</see>
+        /// </remarks>
         public event OnNewPresenceDelegate OnNewPresence;
 
         public delegate void OnRemovePresenceDelegate(UUID agentId);
 
+        /// <summary>
+        /// Triggered when a presence is removed from the scene
+        /// </summary>
+        /// <remarks>
+        /// Triggered in <see cref="OpenSim.Region.Framework.Scenes.Scene.AddNewClient"/> which is used by both
+        /// <see cref="OpenSim.Framework.PresenceType.User">users</see> and <see cref="OpenSim.Framework.PresenceType.Npc">NPCs</see>
+        /// 
+        /// Triggered under per-agent lock.  So if you want to perform any long-running operations, please
+        /// do this on a separate thread.
+        /// </remarks>
         public event OnRemovePresenceDelegate OnRemovePresence;
 
         public delegate void OnParcelPrimCountUpdateDelegate();
 
+        /// <summary>
+        /// Triggered whenever the prim count may have been altered, or prior
+        /// to an action that requires the current prim count to be accurate.
+        /// </summary>
+        /// <remarks>
+        /// Triggered by <see cref="TriggerParcelPrimCountUpdate"/> in
+        /// <see cref="OpenSim.OpenSimBase.CreateRegion"/>,
+        /// <see cref="OpenSim.Region.CoreModules.World.Land.LandManagementModule.EventManagerOnRequestParcelPrimCountUpdate"/>,
+        /// <see cref="OpenSim.Region.CoreModules.World.Land.LandManagementModule.ClientOnParcelObjectOwnerRequest"/>,
+        /// <see cref="OpenSim.Region.CoreModules.World.Land.LandObject.GetPrimsFree"/>,
+        /// <see cref="OpenSim.Region.CoreModules.World.Land.LandObject.UpdateLandSold"/>,
+        /// <see cref="OpenSim.Region.CoreModules.World.Land.LandObject.DeedToGroup"/>,
+        /// <see cref="OpenSim.Region.CoreModules.World.Land.LandObject.SendLandUpdateToClient"/>
+        /// </remarks>
         public event OnParcelPrimCountUpdateDelegate OnParcelPrimCountUpdate;
 
         public delegate void OnParcelPrimCountAddDelegate(SceneObjectGroup obj);
 
+        /// <summary>
+        /// Triggered in response to <see cref="OnParcelPrimCountUpdate"/> for
+        /// objects that actually contribute to parcel prim count.
+        /// </summary>
+        /// <remarks>
+        /// Triggered by <see cref="TriggerParcelPrimCountAdd"/> in
+        /// <see cref="OpenSim.Region.CoreModules.World.Land.LandManagementModule.EventManagerOnParcelPrimCountUpdate"/>
+        /// </remarks>
         public event OnParcelPrimCountAddDelegate OnParcelPrimCountAdd;
 
         public delegate void OnPluginConsoleDelegate(string[] args);
 
+        /// <summary>
+        /// Triggered after <see cref="OpenSim.IApplicationPlugin.PostInitialise"/>
+        /// has been called for all <see cref="OpenSim.IApplicationPlugin"/>
+        /// loaded via <see cref="OpenSim.OpenSimBase.LoadPlugins"/>.
+        /// Handlers for this event are typically used to parse the arguments
+        /// from <see cref="OnPluginConsoleDelegate"/> in order to process or
+        /// filter the arguments and pass them onto <see cref="OpenSim.Region.CoreModules.Framework.InterfaceCommander.Commander.ProcessConsoleCommand"/>
+        /// </summary>
+        /// <remarks>
+        /// Triggered by <see cref="TriggerOnPluginConsole"/> in
+        /// <see cref="Scene.SendCommandToPlugins"/> via
+        /// <see cref="SceneManager.SendCommandToPluginModules"/> via
+        /// <see cref="OpenSim.OpenSimBase.HandleCommanderCommand"/> via
+        /// <see cref="OpenSim.OpenSimBase.AddPluginCommands"/> via
+        /// <see cref="OpenSim.OpenSimBase.StartupSpecific"/>
+        /// </remarks>
         public event OnPluginConsoleDelegate OnPluginConsole;
 
         /// <summary>
@@ -121,8 +229,28 @@ namespace OpenSim.Region.Framework.Scenes
 
         public delegate void OnSetRootAgentSceneDelegate(UUID agentID, Scene scene);
 
+        /// <summary>
+        /// Triggered before the grunt work for adding a root agent to a
+        /// scene has been performed (resuming attachment scripts, physics,
+        /// animations etc.)
+        /// </summary>
+        /// <remarks>
+        /// Triggered before <see cref="OnMakeRootAgent"/>
+        /// by <see cref="TriggerSetRootAgentScene"/>
+        /// in <see cref="ScenePresence.MakeRootAgent"/>
+        /// via <see cref="Scene.AgentCrossing"/>
+        /// and <see cref="ScenePresence.CompleteMovement"/>
+        /// </remarks>
         public event OnSetRootAgentSceneDelegate OnSetRootAgentScene;
 
+        /// <summary>
+        /// Triggered after parcel properties have been updated.
+        /// </summary>
+        /// <remarks>
+        /// Triggered by <see cref="TriggerOnParcelPropertiesUpdateRequest"/> in
+        /// <see cref="OpenSim.Region.CoreModules.World.Land.LandManagementModule.ClientOnParcelPropertiesUpdateRequest"/>,
+        /// <see cref="OpenSim.Region.CoreModules.World.Land.LandManagementModule.ProcessPropertiesUpdate"/>
+        /// </remarks>
         public event ParcelPropertiesUpdateRequest OnParcelPropertiesUpdateRequest;
 
         /// <summary>
@@ -137,13 +265,45 @@ namespace OpenSim.Region.Framework.Scenes
         /// <summary>
         /// Fired when an object is touched/grabbed.
         /// </summary>
+        /// <remarks>
         /// The originalID is the local ID of the part that was actually touched.  The localID itself is always that of
         /// the root part.
+        /// Triggerd in response to <see cref="OpenSim.Framework.IClientAPI.OnGrabObject"/>
+        /// via <see cref="TriggerObjectGrab"/>
+        /// in <see cref="Scene.ProcessObjectGrab"/>
+        /// </remarks>
         public event ObjectGrabDelegate OnObjectGrab;
         public delegate void ObjectGrabDelegate(uint localID, uint originalID, Vector3 offsetPos, IClientAPI remoteClient, SurfaceTouchEventArgs surfaceArgs);
         
+        /// <summary>
+        /// Triggered when an object is being touched/grabbed continuously.
+        /// </summary>
+        /// <remarks>
+        /// Triggered in response to <see cref="OpenSim.Framework.IClientAPI.OnGrabUpdate"/>
+        /// via <see cref="TriggerObjectGrabbing"/>
+        /// in <see cref="Scene.ProcessObjectGrabUpdate"/>
+        /// </remarks>
         public event ObjectGrabDelegate OnObjectGrabbing;
+
+        /// <summary>
+        /// Triggered when an object stops being touched/grabbed.
+        /// </summary>
+        /// <remarks>
+        /// Triggered in response to <see cref="OpenSim.Framework.IClientAPI.OnDeGrabObject"/>
+        /// via <see cref="TriggerObjectDeGrab"/>
+        /// in <see cref="Scene.ProcessObjectDeGrab"/>
+        /// </remarks>
         public event ObjectDeGrabDelegate OnObjectDeGrab;
+
+        /// <summary>
+        /// Triggered when a script resets.
+        /// </summary>
+        /// <remarks>
+        /// Triggered by <see cref="TriggerScriptReset"/>
+        /// in <see cref="Scene.ProcessScriptReset"/>
+        /// via <see cref="OpenSim.Framework.IClientAPI.OnScriptReset"/>
+        /// via <see cref="OpenSim.Region.ClientStack.LindenUDP.LLClientView.HandleScriptReset"/>
+        /// </remarks>
         public event ScriptResetDelegate OnScriptReset;
 
         public event OnPermissionErrorDelegate OnPermissionError;
@@ -153,29 +313,105 @@ namespace OpenSim.Region.Framework.Scenes
         /// </summary>
         /// <remarks>
         /// Occurs after OnNewScript.
+        /// Triggered by <see cref="TriggerRezScript"/>
+        /// in <see cref="SceneObjectPartInventory.CreateScriptInstance"/>
         /// </remarks>
         public event NewRezScript OnRezScript;
         public delegate void NewRezScript(uint localID, UUID itemID, string script, int startParam, bool postOnRez, string engine, int stateSource);
 
         public delegate void RemoveScript(uint localID, UUID itemID);
+
+        /// <summary>
+        /// Triggered when a script is removed from an object.
+        /// </summary>
+        /// <remarks>
+        /// Triggered by <see cref="TriggerRemoveScript"/>
+        /// in <see cref="Scene.RemoveTaskInventory"/>,
+        /// <see cref="Scene.CreateAgentInventoryItemFromTask"/>,
+        /// <see cref="SceneObjectPartInventory.RemoveScriptInstance"/>,
+        /// <see cref="SceneObjectPartInventory.RemoveInventoryItem"/>
+        /// </remarks>
         public event RemoveScript OnRemoveScript;
 
         public delegate void StartScript(uint localID, UUID itemID);
+
+        /// <summary>
+        /// Triggered when a script starts.
+        /// </summary>
+        /// <remarks>
+        /// Triggered by <see cref="TriggerStartScript"/>
+        /// in <see cref="Scene.SetScriptRunning"/>
+        /// via <see cref="OpenSim.Framework.IClientAPI.OnSetScriptRunning"/>,
+        /// via <see cref="OpenSim.Region.ClientStack.LindenUDP.HandleSetScriptRunning"/>
+        /// </remarks>
         public event StartScript OnStartScript;
 
         public delegate void StopScript(uint localID, UUID itemID);
+
+        /// <summary>
+        /// Triggered when a script stops.
+        /// </summary>
+        /// <remarks>
+        /// Triggered by <see cref="TriggerStopScript"/>,
+        /// in <see cref="SceneObjectPartInventory.CreateScriptInstance"/>,
+        /// <see cref="SceneObjectPartInventory.StopScriptInstance"/>,
+        /// <see cref="Scene.SetScriptRunning"/>
+        /// </remarks>
         public event StopScript OnStopScript;
 
         public delegate bool SceneGroupMoved(UUID groupID, Vector3 delta);
+
+        /// <summary>
+        /// Triggered when an object is moved.
+        /// </summary>
+        /// <remarks>
+        /// Triggered by <see cref="TriggerGroupMove"/>
+        /// in <see cref="SceneObjectGroup.UpdateGroupPosition"/>,
+        /// <see cref="SceneObjectGroup.GrabMovement"/>
+        /// </remarks>
         public event SceneGroupMoved OnSceneGroupMove;
 
         public delegate void SceneGroupGrabed(UUID groupID, Vector3 offset, UUID userID);
+
+        /// <summary>
+        /// Triggered when an object is grabbed.
+        /// </summary>
+        /// <remarks>
+        /// Triggered by <see cref="TriggerGroupGrab"/>
+        /// in <see cref="SceneObjectGroup.OnGrabGroup"/>
+        /// via <see cref="SceneObjectGroup.ObjectGrabHandler"/>
+        /// via <see cref="Scene.ProcessObjectGrab"/>
+        /// via <see cref="OpenSim.Framework.IClientAPI.OnGrabObject"/>
+        /// via <see cref="OpenSim.Region.ClientStack.LindenUDP.LLClientView.HandleObjectGrab"/>
+        /// </remarks>
         public event SceneGroupGrabed OnSceneGroupGrab;
 
         public delegate bool SceneGroupSpinStarted(UUID groupID);
+
+        /// <summary>
+        /// Triggered when an object starts to spin.
+        /// </summary>
+        /// <remarks>
+        /// Triggered by <see cref="TriggerGroupSpinStart"/>
+        /// in <see cref="SceneObjectGroup.SpinStart"/>
+        /// via <see cref="SceneGraph.SpinStart"/>
+        /// via <see cref="OpenSim.Framework.IClientAPI.OnSpinStart"/>
+        /// via <see cref="OpenSim.Region.ClientStack.LindenUDP.LLClientView.HandleObjectSpinStart"/>
+        /// </remarks>
         public event SceneGroupSpinStarted OnSceneGroupSpinStart;
 
         public delegate bool SceneGroupSpun(UUID groupID, Quaternion rotation);
+
+        /// <summary>
+        /// Triggered when an object is being spun.
+        /// </summary>
+        /// <remarks>
+        /// Triggered by <see cref="TriggerGroupSpin"/>
+        /// in <see cref="SceneObjectGroup.SpinMovement"/>
+        /// via <see cref="SceneGraph.SpinObject"/>
+        /// via <see cref="OpenSim.Framework.IClientAPI.OnSpinUpdate"/>
+        /// via <see cref="OpenSim.Region.ClientStack.LindenUDP.LLClientView.HandleObjectSpinUpdate"/>
+        /// </remarks>
         public event SceneGroupSpun OnSceneGroupSpin;
 
         public delegate void LandObjectAdded(ILandObject newParcel);
@@ -204,6 +440,9 @@ namespace OpenSim.Region.Framework.Scenes
         /// </summary>
         /// <remarks>
         /// At the point of firing, the scene still contains the client's scene presence.
+        ///
+        /// This is triggered under per-agent lock.  So if you want to perform any long-running operations, please
+        /// do this on a separate thread.
         /// </remarks>
         public event ClientClosed OnClientClosed;
 
@@ -214,6 +453,9 @@ namespace OpenSim.Region.Framework.Scenes
         /// </summary>
         /// <remarks>
         /// Occurs before OnRezScript
+        /// Triggered by <see cref="TriggerNewScript"/>
+        /// in <see cref="Scene.RezScriptFromAgentInventory"/>,
+        /// <see cref="Scene.RezNewScript"/>
         /// </remarks>
         public event NewScript OnNewScript;
 
@@ -248,6 +490,12 @@ namespace OpenSim.Region.Framework.Scenes
         /// </summary>
         /// <remarks>
         /// Triggered after the scene receives a client's upload of an updated script and has stored it in an asset.
+        /// Triggered by <see cref="TriggerUpdateScript"/>
+        /// in <see cref="Scene.CapsUpdateTaskInventoryScriptAsset"/>
+        /// via <see cref="Scene.CapsUpdateTaskInventoryScriptAsset"/>
+        /// via <see cref="OpenSim.Region.ClientStack.Linden.BunchOfCaps.TaskScriptUpdated"/>
+        /// via <see cref="OpenSim.Region.ClientStack.Linden.TaskInventoryScriptUpdater.OnUpLoad"/>
+        /// via <see cref="OpenSim.Region.ClientStack.Linden.TaskInventoryScriptUpdater.uploaderCaps"/>
         /// </remarks>
         public event UpdateScript OnUpdateScript;
         
@@ -273,48 +521,203 @@ namespace OpenSim.Region.Framework.Scenes
         } 
 
         /// <summary>
+        /// Triggered when some scene object properties change.
+        /// </summary>
+        /// <remarks>
         /// ScriptChangedEvent is fired when a scene object property that a script might be interested 
         /// in (such as color, scale or inventory) changes.  Only enough information sent is for the LSL changed event.
         /// This is not an indication that the script has changed (see OnUpdateScript for that). 
         /// This event is sent to a script to tell it that some property changed on 
         /// the object the script is in. See http://lslwiki.net/lslwiki/wakka.php?wakka=changed .
-        /// </summary>
+        /// Triggered by <see cref="TriggerOnScriptChangedEvent"/>
+        /// in <see cref="OpenSim.Region.CoreModules.Framework.EntityTransfer.EntityTransferModule.TeleportAgentWithinRegion"/>,
+        /// <see cref="SceneObjectPart.TriggerScriptChangedEvent"/>
+        /// </remarks>
         public event ScriptChangedEvent OnScriptChangedEvent;
         public delegate void ScriptChangedEvent(uint localID, uint change);
 
         public delegate void ScriptControlEvent(UUID item, UUID avatarID, uint held, uint changed);
+
+        /// <summary>
+        /// Triggered when a script receives control input from an agent.
+        /// </summary>
+        /// <remarks>
+        /// Triggered by <see cref="TriggerControlEvent"/>
+        /// in <see cref="ScenePresence.SendControlsToScripts"/>
+        /// via <see cref="ScenePresence.HandleAgentUpdate"/>
+        /// via <see cref="OpenSim.Framework.IClientAPI.OnAgentUpdate"/>
+        /// via <see cref="OpenSim.Region.ClientStack.LindenUDP.LLClientView.HandleAgentUpdate"/>
+        /// </remarks>
         public event ScriptControlEvent OnScriptControlEvent;
 
         public delegate void ScriptAtTargetEvent(uint localID, uint handle, Vector3 targetpos, Vector3 atpos);
+
+        /// <summary>
+        /// Triggered when an object has arrived within a tolerance distance
+        /// of a motion target.
+        /// </summary>
+        /// <remarks>
+        /// Triggered by <see cref="TriggerAtTargetEvent"/>
+        /// in <see cref="SceneObjectGroup.checkAtTargets"/>
+        /// via <see cref="SceneObjectGroup.ScheduleGroupForFullUpdate"/>,
+        /// <see cref="Scene.CheckAtTargets"/> via <see cref="Scene.Update"/>
+        /// </remarks>
         public event ScriptAtTargetEvent OnScriptAtTargetEvent;
 
         public delegate void ScriptNotAtTargetEvent(uint localID);
+
+        /// <summary>
+        /// Triggered when an object has a motion target but has not arrived
+        /// within a tolerance distance.
+        /// </summary>
+        /// <remarks>
+        /// Triggered by <see cref="TriggerNotAtTargetEvent"/>
+        /// in <see cref="SceneObjectGroup.checkAtTargets"/>
+        /// via <see cref="SceneObjectGroup.ScheduleGroupForFullUpdate"/>,
+        /// <see cref="Scene.CheckAtTargets"/> via <see cref="Scene.Update"/>
+        /// </remarks>
         public event ScriptNotAtTargetEvent OnScriptNotAtTargetEvent;
 
         public delegate void ScriptAtRotTargetEvent(uint localID, uint handle, Quaternion targetrot, Quaternion atrot);
+
+        /// <summary>
+        /// Triggered when an object has arrived within a tolerance rotation
+        /// of a rotation target.
+        /// </summary>
+        /// <remarks>
+        /// Triggered by <see cref="TriggerAtRotTargetEvent"/>
+        /// in <see cref="SceneObjectGroup.checkAtTargets"/>
+        /// via <see cref="SceneObjectGroup.ScheduleGroupForFullUpdate"/>,
+        /// <see cref="Scene.CheckAtTargets"/> via <see cref="Scene.Update"/>
+        /// </remarks>
         public event ScriptAtRotTargetEvent OnScriptAtRotTargetEvent;
 
         public delegate void ScriptNotAtRotTargetEvent(uint localID);
+
+        /// <summary>
+        /// Triggered when an object has a rotation target but has not arrived
+        /// within a tolerance rotation.
+        /// </summary>
+        /// <remarks>
+        /// Triggered by <see cref="TriggerNotAtRotTargetEvent"/>
+        /// in <see cref="SceneObjectGroup.checkAtTargets"/>
+        /// via <see cref="SceneObjectGroup.ScheduleGroupForFullUpdate"/>,
+        /// <see cref="Scene.CheckAtTargets"/> via <see cref="Scene.Update"/>
+        /// </remarks>
         public event ScriptNotAtRotTargetEvent OnScriptNotAtRotTargetEvent;
 
         public delegate void ScriptColliding(uint localID, ColliderArgs colliders);
+
+        /// <summary>
+        /// Triggered when a physical collision has started between a prim
+        /// and something other than the region terrain.
+        /// </summary>
+        /// <remarks>
+        /// Triggered by <see cref="TriggerScriptCollidingStart"/>
+        /// in <see cref="SceneObjectPart.SendCollisionEvent"/>
+        /// via <see cref="SceneObjectPart.PhysicsCollision"/>
+        /// via <see cref="OpenSim.Region.Physics.Manager.PhysicsActor.OnCollisionUpdate"/>
+        /// via <see cref="OpenSim.Region.Physics.Manager.PhysicsActor.SendCollisionUpdate"/>
+        /// </remarks>
         public event ScriptColliding OnScriptColliderStart;
+
+        /// <summary>
+        /// Triggered when something that previously collided with a prim has
+        /// not stopped colliding with it.
+        /// </summary>
+        /// <remarks>
+        /// <seealso cref="OnScriptColliderStart"/>
+        /// Triggered by <see cref="TriggerScriptColliding"/>
+        /// in <see cref="SceneObjectPart.SendCollisionEvent"/>
+        /// via <see cref="SceneObjectPart.PhysicsCollision"/>
+        /// via <see cref="OpenSim.Region.Physics.Manager.PhysicsActor.OnCollisionUpdate"/>
+        /// via <see cref="OpenSim.Region.Physics.Manager.PhysicsActor.SendCollisionUpdate"/>
+        /// </remarks>
         public event ScriptColliding OnScriptColliding;
+
+        /// <summary>
+        /// Triggered when something that previously collided with a prim has
+        /// stopped colliding with it.
+        /// </summary>
+        /// <remarks>
+        /// Triggered by <see cref="TriggerScriptCollidingEnd"/>
+        /// in <see cref="SceneObjectPart.SendCollisionEvent"/>
+        /// via <see cref="SceneObjectPart.PhysicsCollision"/>
+        /// via <see cref="OpenSim.Region.Physics.Manager.PhysicsActor.OnCollisionUpdate"/>
+        /// via <see cref="OpenSim.Region.Physics.Manager.PhysicsActor.SendCollisionUpdate"/>
+        /// </remarks>
         public event ScriptColliding OnScriptCollidingEnd;
+
+        /// <summary>
+        /// Triggered when a physical collision has started between an object
+        /// and the region terrain.
+        /// </summary>
+        /// <remarks>
+        /// Triggered by <see cref="TriggerScriptLandCollidingStart"/>
+        /// in <see cref="SceneObjectPart.SendLandCollisionEvent"/>
+        /// via <see cref="SceneObjectPart.PhysicsCollision"/>
+        /// via <see cref="OpenSim.Region.Physics.Manager.PhysicsActor.OnCollisionUpdate"/>
+        /// via <see cref="OpenSim.Region.Physics.Manager.PhysicsActor.SendCollisionUpdate"/>
+        /// </remarks>
         public event ScriptColliding OnScriptLandColliderStart;
+
+        /// <summary>
+        /// Triggered when an object that previously collided with the region
+        /// terrain has not yet stopped colliding with it.
+        /// </summary>
+        /// <remarks>
+        /// Triggered by <see cref="TriggerScriptLandColliding"/>
+        /// in <see cref="SceneObjectPart.SendLandCollisionEvent"/>
+        /// via <see cref="SceneObjectPart.PhysicsCollision"/>
+        /// via <see cref="OpenSim.Region.Physics.Manager.PhysicsActor.OnCollisionUpdate"/>
+        /// via <see cref="OpenSim.Region.Physics.Manager.PhysicsActor.SendCollisionUpdate"/>
+        /// </remarks>
         public event ScriptColliding OnScriptLandColliding;
+
+        /// <summary>
+        /// Triggered when an object that previously collided with the region
+        /// terrain has stopped colliding with it.
+        /// </summary>
+        /// <remarks>
+        /// Triggered by <see cref="TriggerScriptLandCollidingEnd"/>
+        /// in <see cref="SceneObjectPart.SendLandCollisionEvent"/>
+        /// via <see cref="SceneObjectPart.PhysicsCollision"/>
+        /// via <see cref="OpenSim.Region.Physics.Manager.PhysicsActor.OnCollisionUpdate"/>
+        /// via <see cref="OpenSim.Region.Physics.Manager.PhysicsActor.SendCollisionUpdate"/>
+        /// </remarks>
         public event ScriptColliding OnScriptLandColliderEnd;
 
         public delegate void OnMakeChildAgentDelegate(ScenePresence presence);
+
+        /// <summary>
+        /// Triggered when an agent has been made a child agent of a scene.
+        /// </summary>
+        /// <remarks>
+        /// Triggered by <see cref="TriggerOnMakeChildAgent"/>
+        /// in <see cref="ScenePresence.MakeChildAgent"/>
+        /// via <see cref="OpenSim.Region.CoreModules.Framework.EntityTransfer.EntityTransferModule.CrossAgentToNewRegionAsync"/>,
+        /// <see cref="OpenSim.Region.CoreModules.Framework.EntityTransfer.EntityTransferModule.DoTeleport"/>,
+        /// <see cref="OpenSim.Region.CoreModules.InterGrid.KillAUser.ShutdownNoLogout"/>
+        /// </remarks>
         public event OnMakeChildAgentDelegate OnMakeChildAgent;
 
         public delegate void OnSaveNewWindlightProfileDelegate();
         public delegate void OnSendNewWindlightProfileTargetedDelegate(RegionLightShareData wl, UUID user);
 
         /// <summary>
+        /// Triggered after the grunt work for adding a root agent to a
+        /// scene has been performed (resuming attachment scripts, physics,
+        /// animations etc.)
+        /// </summary>
+        /// <remarks>
         /// This event is on the critical path for transferring an avatar from one region to another.  Try and do
         /// as little work on this event as possible, or do work asynchronously.
-        /// </summary>
+        /// Triggered after <see cref="OnSetRootAgentScene"/>
+        /// by <see cref="TriggerOnMakeRootAgent"/>
+        /// in <see cref="ScenePresence.MakeRootAgent"/>
+        /// via <see cref="Scene.AgentCrossing"/>
+        /// and <see cref="ScenePresence.CompleteMovement"/>
+        /// </remarks>
         public event Action<ScenePresence> OnMakeRootAgent;
         
         public event OnSendNewWindlightProfileTargetedDelegate OnSendNewWindlightProfileTargeted;
@@ -340,9 +743,17 @@ namespace OpenSim.Region.Framework.Scenes
         public event AvatarKillData OnAvatarKilled;
         public delegate void AvatarKillData(uint KillerLocalID, ScenePresence avatar);
 
-//        public delegate void ScriptTimerEvent(uint localID, double timerinterval);
-
-//        public event ScriptTimerEvent OnScriptTimerEvent;
+        /*
+        public delegate void ScriptTimerEvent(uint localID, double timerinterval);
+        /// <summary>
+        /// Used to be triggered when the LSL timer event fires.
+        /// </summary>
+        /// <remarks>
+        /// Triggered by <see cref="TriggerTimerEvent"/>
+        /// via <see cref="SceneObjectPart.handleTimerAccounting"/>
+        /// </remarks>
+        public event ScriptTimerEvent OnScriptTimerEvent;
+         */
 
         public delegate void EstateToolsSunUpdate(ulong regionHandle, bool FixedTime, bool EstateSun, float LindenHour);
         public delegate void GetScriptRunning(IClientAPI controllingClient, UUID objectID, UUID itemID);
@@ -352,12 +763,27 @@ namespace OpenSim.Region.Framework.Scenes
         /// <summary>
         /// Triggered when an object is added to the scene.
         /// </summary>
+        /// <remarks>
+        /// Triggered by <see cref="TriggerObjectAddedToScene"/>
+        /// in <see cref="Scene.AddNewSceneObject"/>,
+        /// <see cref="Scene.DuplicateObject"/>,
+        /// <see cref="Scene.doObjectDuplicateOnRay"/>
+        /// </remarks>
         public event Action<SceneObjectGroup> OnObjectAddedToScene;
 
         /// <summary>
-        /// Triggered when an object is removed from the scene.
+        /// Delegate for <see cref="OnObjectBeingRemovedFromScene"/>
         /// </summary>
+        /// <param name="obj">The object being removed from the scene</param>
         public delegate void ObjectBeingRemovedFromScene(SceneObjectGroup obj);
+
+        /// <summary>
+        /// Triggered when an object is removed from the scene.
+        /// </summary>
+        /// <remarks>
+        /// Triggered by <see cref="TriggerObjectBeingRemovedFromScene"/>
+        /// in <see cref="Scene.DeleteSceneObject"/>
+        /// </remarks>
         public event ObjectBeingRemovedFromScene OnObjectBeingRemovedFromScene;
 
         public delegate void NoticeNoLandDataFromStorage();
@@ -373,6 +799,20 @@ namespace OpenSim.Region.Framework.Scenes
         public event RequestParcelPrimCountUpdate OnRequestParcelPrimCountUpdate;
 
         public delegate void ParcelPrimCountTainted();
+
+        /// <summary>
+        /// Triggered when the parcel prim count has been altered.
+        /// </summary>
+        /// <remarks>
+        /// Triggered by <see cref="TriggerParcelPrimCountTainted"/> in
+        /// <see cref="OpenSim.Region.CoreModules.Avatar.Attachments.AttachmentsModule.DetachSingleAttachmentToGround"/>,
+        /// <see cref="OpenSim.Region.CoreModules.Avatar.Attachments.AttachmentsModule.AttachToAgent"/>,
+        /// <see cref="Scene.DeleteSceneObject"/>,
+        /// <see cref="Scene.SelectPrim"/>,
+        /// <see cref="Scene.DeselectPrim"/>,
+        /// <see cref="SceneObjectGroup.UpdatePrimFlags"/>,
+        /// <see cref="SceneObjectGroup.AbsolutePosition"/>
+        /// </remarks>
         public event ParcelPrimCountTainted OnParcelPrimCountTainted;
         public event GetScriptRunning OnGetScriptRunning;
 
@@ -432,7 +872,7 @@ namespace OpenSim.Region.Framework.Scenes
         /// the scripts may not have started yet
         /// Message is non empty string if there were problems loading the oar file
         /// </summary>
-        public delegate void OarFileLoaded(Guid guid, string message);
+        public delegate void OarFileLoaded(Guid guid, List<UUID> loadedScenes, string message);
         public event OarFileLoaded OnOarFileLoaded;
         
         /// <summary>
@@ -485,10 +925,13 @@ namespace OpenSim.Region.Framework.Scenes
         /// <param name="copy"></param>
         /// <param name="original"></param>
         /// <param name="userExposed">True if the duplicate will immediately be in the scene, false otherwise</param>
+        /// <remarks>
+        /// Triggered in <see cref="OpenSim.Region.Framework.Scenes.SceneObjectPart.Copy"/>
+        /// </remarks>
         public event SceneObjectPartCopyDelegate OnSceneObjectPartCopy;
         public delegate void SceneObjectPartCopyDelegate(SceneObjectPart copy, SceneObjectPart original, bool userExposed);
 
-        public delegate void SceneObjectPartUpdated(SceneObjectPart sop);
+        public delegate void SceneObjectPartUpdated(SceneObjectPart sop, bool full);
         public event SceneObjectPartUpdated OnSceneObjectPartUpdated;
 
         public delegate void ScenePresenceUpdated(ScenePresence sp);
@@ -526,9 +969,28 @@ namespace OpenSim.Region.Framework.Scenes
         public event PrimsLoaded OnPrimsLoaded;
 
         public delegate void TeleportStart(IClientAPI client, GridRegion destination, GridRegion finalDestination, uint teleportFlags, bool gridLogout);
+
+        /// <summary>
+        /// Triggered when a teleport starts
+        /// </summary>
+        /// <remarks>
+        /// Triggered by <see cref="TriggerTeleportStart"/>
+        /// in <see cref="OpenSim.Region.CoreModules.Framework.EntityTransfer.EntityTransferModule.CreateAgent"/>
+        /// and <see cref="OpenSim.Region.CoreModules.Framework.EntityTransfer.HGEntityTransferModule.CreateAgent"/>
+        /// via <see cref="OpenSim.Region.CoreModules.Framework.EntityTransfer.EntityTransferModule.DoTeleport"/>
+        /// </remarks>
         public event TeleportStart OnTeleportStart;
 
         public delegate void TeleportFail(IClientAPI client, bool gridLogout);
+
+        /// <summary>
+        /// Trigered when a teleport fails.
+        /// </summary>
+        /// <remarks>
+        /// Triggered by <see cref="TriggerTeleportFail"/>
+        /// in <see cref="OpenSim.Region.CoreModules.Framework.EntityTransfer.EntityTransferModule.Fail"/>
+        /// via <see cref="OpenSim.Region.CoreModules.Framework.EntityTransfer.EntityTransferModule.DoTeleport"/>
+        /// </remarks>
         public event TeleportFail OnTeleportFail;
 
         public class MoneyTransferArgs : EventArgs
@@ -536,7 +998,9 @@ namespace OpenSim.Region.Framework.Scenes
             public UUID sender;
             public UUID receiver;
 
-            // Always false. The SL protocol sucks.
+            /// <summary>
+            /// Always false. The SL protocol sucks.
+            /// </summary>
             public bool authenticated = false;
 
             public int amount;
@@ -593,8 +1057,29 @@ namespace OpenSim.Region.Framework.Scenes
 
         public delegate void LandBuy(Object sender, LandBuyArgs e);
 
+        /// <summary>
+        /// Triggered when an attempt to transfer grid currency occurs
+        /// </summary>
+        /// <remarks>
+        /// Triggered in <see cref="OpenSim.Region.Framework.Scenes.Scene.ProcessMoneyTransferRequest"/>
+        /// via <see cref="OpenSim.Region.Framework.Scenes.Scene.SubscribeToClientGridEvents"/>
+        /// via <see cref="OpenSim.Region.Framework.Scenes.Scene.SubscribeToClientEvents"/>
+        /// via <see cref="OpenSim.Region.Framework.Scenes.Scene.AddNewClient"/>
+        /// </remarks>
         public event MoneyTransferEvent OnMoneyTransfer;
+
+        /// <summary>
+        /// Triggered after after <see cref="OnValidateLandBuy"/>
+        /// </summary>
         public event LandBuy OnLandBuy;
+
+        /// <summary>
+        /// Triggered to allow or prevent a real estate transaction
+        /// </summary>
+        /// <remarks>
+        /// Triggered in <see cref="OpenSim.Region.Framework.Scenes.Scene.ProcessParcelBuy"/>
+        /// <seealso cref="OpenSim.Region.OptionalModules.World.MoneyModule.SampleMoneyModule.ValidateLandBuy"/>
+        /// </remarks>
         public event LandBuy OnValidateLandBuy;
 
         public void TriggerOnAttach(uint localID, UUID itemID, UUID avatarID)
@@ -2031,7 +2516,11 @@ namespace OpenSim.Region.Framework.Scenes
             }
         }
 
-        // this lets us keep track of nasty script events like timer, etc.
+        /// <summary>
+        /// this lets us keep track of nasty script events like timer, etc.
+        /// </summary>
+        /// <param name="objLocalID"></param>
+        /// <param name="Interval"></param>
         public void TriggerTimerEvent(uint objLocalID, double Interval)
         {
             throw new NotImplementedException("TriggerTimerEvent was thought to be not used anymore and the registration for the event from scene object part has been commented out due to a memory leak");
@@ -2093,7 +2582,7 @@ namespace OpenSim.Region.Framework.Scenes
             return 6;
         }
 
-        public void TriggerOarFileLoaded(Guid requestId, string message)
+        public void TriggerOarFileLoaded(Guid requestId, List<UUID> loadedScenes, string message)
         {
             OarFileLoaded handlerOarFileLoaded = OnOarFileLoaded;
             if (handlerOarFileLoaded != null)
@@ -2102,7 +2591,7 @@ namespace OpenSim.Region.Framework.Scenes
                 {
                     try
                     {
-                        d(requestId, message);
+                        d(requestId, loadedScenes, message);
                     }
                     catch (Exception e)
                     {
@@ -2387,7 +2876,7 @@ namespace OpenSim.Region.Framework.Scenes
             }
         }
 
-        public void TriggerSceneObjectPartUpdated(SceneObjectPart sop)
+        public void TriggerSceneObjectPartUpdated(SceneObjectPart sop, bool full)
         {
             SceneObjectPartUpdated handler = OnSceneObjectPartUpdated;
             if (handler != null)
@@ -2396,7 +2885,7 @@ namespace OpenSim.Region.Framework.Scenes
                 {
                     try
                     {
-                        d(sop);
+                        d(sop, full);
                     }
                     catch (Exception e)
                     {
diff --git a/OpenSim/Region/Framework/Scenes/Scene.Inventory.cs b/OpenSim/Region/Framework/Scenes/Scene.Inventory.cs
index ff8589a..deb57ce 100644
--- a/OpenSim/Region/Framework/Scenes/Scene.Inventory.cs
+++ b/OpenSim/Region/Framework/Scenes/Scene.Inventory.cs
@@ -93,7 +93,7 @@ namespace OpenSim.Region.Framework.Scenes
         /// </summary>
         public void StartScripts()
         {
-            m_log.InfoFormat("[SCENE]: Starting scripts in {0}, please wait.", RegionInfo.RegionName);
+//            m_log.InfoFormat("[SCENE]: Starting scripts in {0}, please wait.", RegionInfo.RegionName);
 
             IScriptModule[] engines = RequestModuleInterfaces<IScriptModule>();
 
@@ -1469,7 +1469,7 @@ namespace OpenSim.Region.Framework.Scenes
             return newFolderID;
         }
 
-        private void SendInventoryUpdate(IClientAPI client, InventoryFolderBase folder, bool fetchFolders, bool fetchItems)
+        public void SendInventoryUpdate(IClientAPI client, InventoryFolderBase folder, bool fetchFolders, bool fetchItems)
         {
             if (folder == null)
                 return;
@@ -1997,6 +1997,9 @@ namespace OpenSim.Region.Framework.Scenes
                 // If child prims have invalid perms, fix them
                 grp.AdjustChildPrimPermissions();
 
+                // If child prims have invalid perms, fix them
+                grp.AdjustChildPrimPermissions();
+
                 if (remoteClient == null)
                 {
                     // Autoreturn has a null client. Nothing else does. So
diff --git a/OpenSim/Region/Framework/Scenes/Scene.PacketHandlers.cs b/OpenSim/Region/Framework/Scenes/Scene.PacketHandlers.cs
index e970543..ce6415a 100644
--- a/OpenSim/Region/Framework/Scenes/Scene.PacketHandlers.cs
+++ b/OpenSim/Region/Framework/Scenes/Scene.PacketHandlers.cs
@@ -38,8 +38,20 @@ namespace OpenSim.Region.Framework.Scenes
 {
     public partial class Scene
     {
+        /// <summary>
+        /// Send chat to listeners.
+        /// </summary>
+        /// <param name='message'></param>
+        /// <param name='type'>/param>
+        /// <param name='channel'></param>
+        /// <param name='fromPos'></param>
+        /// <param name='fromName'></param>
+        /// <param name='fromID'></param>
+        /// <param name='targetID'></param>
+        /// <param name='fromAgent'></param>
+        /// <param name='broadcast'></param>
         public void SimChat(byte[] message, ChatTypeEnum type, int channel, Vector3 fromPos, string fromName,
-                               UUID fromID, bool fromAgent, bool broadcast, UUID destination)
+                               UUID fromID, UUID targetID, bool fromAgent, bool broadcast)
         {
             OSChatMessage args = new OSChatMessage();
 
@@ -49,7 +61,7 @@ namespace OpenSim.Region.Framework.Scenes
             args.Position = fromPos;
             args.SenderUUID = fromID;
             args.Scene = this;
-            args.Destination = destination;
+            args.Destination = targetID;
 
             if (fromAgent)
             {
@@ -66,6 +78,10 @@ namespace OpenSim.Region.Framework.Scenes
             args.From = fromName;
             //args.
 
+//            m_log.DebugFormat(
+//                "[SCENE]: Sending message {0} on channel {1}, type {2} from {3}, broadcast {4}",
+//                args.Message.Replace("\n", "\\n"), args.Channel, args.Type, fromName, broadcast);
+
             if (broadcast)
                 EventManager.TriggerOnChatBroadcast(this, args);
             else
@@ -75,7 +91,7 @@ namespace OpenSim.Region.Framework.Scenes
         protected void SimChat(byte[] message, ChatTypeEnum type, int channel, Vector3 fromPos, string fromName,
                                UUID fromID, bool fromAgent, bool broadcast)
         {
-            SimChat(message, type, channel, fromPos, fromName, fromID, fromAgent, broadcast, UUID.Zero);
+            SimChat(message, type, channel, fromPos, fromName, fromID, UUID.Zero, fromAgent, broadcast);
         }
 
         /// <summary>
@@ -543,7 +559,7 @@ namespace OpenSim.Region.Framework.Scenes
             if (!InventoryService.AddFolder(folder))
             {
                 m_log.WarnFormat(
-                     "[AGENT INVENTORY]: Failed to move create folder for user {0} {1}",
+                     "[AGENT INVENTORY]: Failed to create folder for user {0} {1}",
                      remoteClient.Name, remoteClient.AgentId);
             }
         }
diff --git a/OpenSim/Region/Framework/Scenes/Scene.cs b/OpenSim/Region/Framework/Scenes/Scene.cs
index 05ce00a..9f87e1e 100644
--- a/OpenSim/Region/Framework/Scenes/Scene.cs
+++ b/OpenSim/Region/Framework/Scenes/Scene.cs
@@ -80,6 +80,11 @@ namespace OpenSim.Region.Framework.Scenes
         public SynchronizeSceneHandler SynchronizeScene;
 
         /// <summary>
+        /// Used to prevent simultaneous calls to RemoveClient() for the same agent from interfering with each other.
+        /// </summary>
+        private object m_removeClientLock = new object();
+
+        /// <summary>
         /// Statistical information for this scene.
         /// </summary>
         public SimStatsReporter StatsReporter { get; private set; }
@@ -103,8 +108,31 @@ namespace OpenSim.Region.Framework.Scenes
         /// </summary>
         public bool CollidablePrims { get; private set; }
 
+        /// <summary>
+        /// Minimum value of the size of a non-physical prim in each axis
+        /// </summary>
+        public float m_minNonphys = 0.001f;
+
+        /// <summary>
+        /// Maximum value of the size of a non-physical prim in each axis
+        /// </summary>
         public float m_maxNonphys = 256;
+
+        /// <summary>
+        /// Minimum value of the size of a physical prim in each axis
+        /// </summary>
+        public float m_minPhys = 0.01f;
+
+        /// <summary>
+        /// Maximum value of the size of a physical prim in each axis
+        /// </summary>
         public float m_maxPhys = 10;
+
+        /// <summary>
+        /// Max prims an object will hold
+        /// </summary>
+        public int m_linksetCapacity = 0;
+
         public bool m_clampPrimSize;
         public bool m_trustBinaries;
         public bool m_allowScriptCrossings;
@@ -285,6 +313,31 @@ namespace OpenSim.Region.Framework.Scenes
         }
         private volatile bool m_shuttingDown;
 
+        /// <summary>
+        /// Is the scene active?
+        /// </summary>
+        /// <remarks>
+        /// If false, maintenance and update loops are not being run.  Updates can still be triggered manually if
+        /// the scene is not active.
+        /// </remarks>
+        public bool Active
+        {
+            get { return m_active; }
+            set
+            {
+                if (value)
+                {
+                    if (!m_active)
+                        Start();
+                }
+                else
+                {
+                    m_active = false;
+                }
+            }
+        }
+        private volatile bool m_active;
+
 //        private int m_lastUpdate;
         private bool m_firstHeartbeat = true;
         
@@ -746,12 +799,24 @@ namespace OpenSim.Region.Framework.Scenes
                     PhysicalPrims = startupConfig.GetBoolean("physical_prim", true);
                     CollidablePrims = startupConfig.GetBoolean("collidable_prim", true);
 
-                    m_maxNonphys = startupConfig.GetFloat("NonphysicalPrimMax", m_maxNonphys);
+                    m_minNonphys = startupConfig.GetFloat("NonPhysicalPrimMin", m_minNonphys);
+                    if (RegionInfo.NonphysPrimMin > 0)
+                    {
+                        m_minNonphys = RegionInfo.NonphysPrimMin;
+                    }
+
+                    m_maxNonphys = startupConfig.GetFloat("NonPhysicalPrimMax", m_maxNonphys);
                     if (RegionInfo.NonphysPrimMax > 0)
                     {
                         m_maxNonphys = RegionInfo.NonphysPrimMax;
                     }
 
+                    m_minPhys = startupConfig.GetFloat("PhysicalPrimMin", m_minPhys);
+                    if (RegionInfo.PhysPrimMin > 0)
+                    {
+                        m_minPhys = RegionInfo.PhysPrimMin;
+                    }
+
                     m_maxPhys = startupConfig.GetFloat("PhysicalPrimMax", m_maxPhys);
 
                     if (RegionInfo.PhysPrimMax > 0)
@@ -759,6 +824,12 @@ namespace OpenSim.Region.Framework.Scenes
                         m_maxPhys = RegionInfo.PhysPrimMax;
                     }
 
+                    m_linksetCapacity = startupConfig.GetInt("LinksetPrims", m_linksetCapacity);
+                    if (RegionInfo.LinksetCapacity > 0)
+                    {
+                        m_linksetCapacity = RegionInfo.LinksetCapacity;
+                    }
+
                     SpawnPointRouting = startupConfig.GetString("SpawnPointRouting", "closest");
                     TelehubAllowLandmarks = startupConfig.GetBoolean("TelehubAllowLandmark", false);
 
@@ -784,13 +855,6 @@ namespace OpenSim.Region.Framework.Scenes
                     m_defaultScriptEngine = startupConfig.GetString("DefaultScriptEngine", "XEngine");
                     m_log.InfoFormat("[SCENE]: Default script engine {0}", m_defaultScriptEngine);
 
-                    IConfig packetConfig = m_config.Configs["PacketPool"];
-                    if (packetConfig != null)
-                    {
-                        PacketPool.Instance.RecyclePackets = packetConfig.GetBoolean("RecyclePackets", true);
-                        PacketPool.Instance.RecycleDataBlocks = packetConfig.GetBoolean("RecycleDataBlocks", true);
-                    }
-
                     m_strictAccessControl = startupConfig.GetBoolean("StrictAccessControl", m_strictAccessControl);
                     m_seeIntoBannedRegion = startupConfig.GetBoolean("SeeIntoBannedRegion", m_seeIntoBannedRegion);
                     CombineRegions = startupConfig.GetBoolean("CombineContiguousRegions", false);
@@ -854,6 +918,8 @@ namespace OpenSim.Region.Framework.Scenes
             }
 
             // FIXME: Ultimately this should be in a module.
+            SendPeriodicAppearanceUpdates = true;
+            
             IConfig appearanceConfig = m_config.Configs["Appearance"];
             if (appearanceConfig != null)
             {
@@ -1151,6 +1217,14 @@ namespace OpenSim.Region.Framework.Scenes
 
         public void SetSceneCoreDebug(Dictionary<string, string> options)
         {
+            if (options.ContainsKey("active"))
+            {
+                bool active;
+
+                if (bool.TryParse(options["active"], out active))
+                    Active = active;
+            }
+
             if (options.ContainsKey("scripting"))
             {
                 bool enableScripts = true;
@@ -1226,6 +1300,12 @@ namespace OpenSim.Region.Framework.Scenes
         // This is the method that shuts down the scene.
         public override void Close()
         {
+            if (m_shuttingDown)
+            {
+                m_log.WarnFormat("[SCENE]: Ignoring close request because already closing {0}", Name);
+                return;
+            }
+
             m_log.InfoFormat("[SCENE]: Closing down the single simulator: {0}", RegionInfo.RegionName);
 
             StatsReporter.Close();
@@ -1269,6 +1349,14 @@ namespace OpenSim.Region.Framework.Scenes
 
             m_sceneGraph.Close();
 
+            if (!GridService.DeregisterRegion(RegionInfo.RegionID))
+                m_log.WarnFormat("[SCENE]: Deregister from grid failed for region {0}", Name);
+
+            base.Close();
+
+            // XEngine currently listens to the EventManager.OnShutdown event to trigger script stop and persistence.
+            // Therefore. we must dispose of the PhysicsScene after this to prevent a window where script code can
+            // attempt to reference a null or disposed physics scene.
             if (PhysicsScene != null)
             {
                 PhysicsScene phys = PhysicsScene;
@@ -1277,12 +1365,6 @@ namespace OpenSim.Region.Framework.Scenes
                 phys.Dispose();
                 phys = null;
             }
-
-            if (!GridService.DeregisterRegion(RegionInfo.RegionID))
-                m_log.WarnFormat("[SCENE]: Deregister from grid failed for region {0}", Name);
-
-            // call the base class Close method.
-            base.Close();
         }
 
         /// <summary>
@@ -1290,6 +1372,8 @@ namespace OpenSim.Region.Framework.Scenes
         /// </summary>
         public void Start()
         {
+            m_active = true;
+
 //            m_log.DebugFormat("[SCENE]: Starting Heartbeat timer for {0}", RegionInfo.RegionName);
 
             //m_heartbeatTimer.Enabled = true;
@@ -1346,7 +1430,7 @@ namespace OpenSim.Region.Framework.Scenes
         #region Update Methods
 
         /// <summary>
-        /// Performs per-frame updates regularly
+        /// Activate the various loops necessary to continually update the scene.
         /// </summary>
         private void Heartbeat()
         {
@@ -1403,7 +1487,7 @@ namespace OpenSim.Region.Framework.Scenes
             List<Vector3> coarseLocations;
             List<UUID> avatarUUIDs;
 
-            while (!m_shuttingDown && (endRun == null || MaintenanceRun < endRun))
+            while (!m_shuttingDown && ((endRun == null && Active) || MaintenanceRun < endRun))
             {
                 runtc = Util.EnvironmentTickCount();
                 ++MaintenanceRun;
@@ -1465,7 +1549,7 @@ namespace OpenSim.Region.Framework.Scenes
             int sleepMS;
             int framestart;
 
-            while (!m_shuttingDown && (endFrame == null || Frame < endFrame))
+            while (!m_shuttingDown && ((endFrame == null && Active) || Frame < endFrame))
             {
                 framestart = Util.EnvironmentTickCount();
                 ++Frame;
@@ -2185,10 +2269,14 @@ namespace OpenSim.Region.Framework.Scenes
         public bool AddRestoredSceneObject(
             SceneObjectGroup sceneObject, bool attachToBackup, bool alreadyPersisted, bool sendClientUpdates)
         {
-            bool result =  m_sceneGraph.AddRestoredSceneObject(sceneObject, attachToBackup, alreadyPersisted, sendClientUpdates);
-            if (result)
+            if (m_sceneGraph.AddRestoredSceneObject(sceneObject, attachToBackup, alreadyPersisted, sendClientUpdates))
+            {
                 sceneObject.IsDeleted = false;
-            return result;
+                EventManager.TriggerObjectAddedToScene(sceneObject);
+                return true;
+            }
+
+            return false;
         }
         
         /// <summary>
@@ -2829,77 +2917,89 @@ namespace OpenSim.Region.Framework.Scenes
 
         public override ISceneAgent AddNewClient(IClientAPI client, PresenceType type)
         {
+            ScenePresence sp;
+            bool vialogin;
+
             // Validation occurs in LLUDPServer
+            //
+            // XXX: A race condition exists here where two simultaneous calls to AddNewClient can interfere with
+            // each other.  In practice, this does not currently occur in the code.
             AgentCircuitData aCircuit = m_authenticateHandler.GetAgentCircuitData(client.CircuitCode);
 
-            bool vialogin
-                = (aCircuit.teleportFlags & (uint)Constants.TeleportFlags.ViaHGLogin) != 0
-                    || (aCircuit.teleportFlags & (uint)Constants.TeleportFlags.ViaLogin) != 0;
-
-            CheckHeartbeat();
-
-            ScenePresence sp = GetScenePresence(client.AgentId);
-
-            // XXX: Not sure how good it is to add a new client if a scene presence already exists.  Possibly this
-            // could occur if a viewer crashes and relogs before the old client is kicked out.  But this could cause
-            // other problems, and possible the code calling AddNewClient() should ensure that no client is already
-            // connected.
-            if (sp == null)
-            {
-                m_log.DebugFormat(
-                    "[SCENE]: Adding new child scene presence {0} {1} to scene {2} at pos {3}",
-                    client.Name, client.AgentId, RegionInfo.RegionName, client.StartPos);
-
-                m_clientManager.Add(client);
-                SubscribeToClientEvents(client);
-
-                sp = m_sceneGraph.CreateAndAddChildScenePresence(client, aCircuit.Appearance, type);
-                m_eventManager.TriggerOnNewPresence(sp);
-
-                sp.TeleportFlags = (TPFlags)aCircuit.teleportFlags;
+            // We lock here on AgentCircuitData to prevent a race condition between the thread adding a new connection
+            // and a simultaneous one that removes it (as can happen if the client is closed at a particular point
+            // whilst connecting).
+            //
+            // It would be easier to lock across all NewUserConnection(), AddNewClient() and
+            // RemoveClient() calls for all agents, but this would allow a slow call (e.g. because of slow service
+            // response in some module listening to AddNewClient()) from holding up unrelated agent calls.
+            //
+            // In practice, the lock (this) in LLUDPServer.AddNewClient() currently lock across all
+            // AddNewClient() operations (though not other ops).
+            // In the future this can be relieved once locking per agent (not necessarily on AgentCircuitData) is improved.
+            lock (aCircuit)
+            {
+                vialogin
+                    = (aCircuit.teleportFlags & (uint)Constants.TeleportFlags.ViaHGLogin) != 0
+                        || (aCircuit.teleportFlags & (uint)Constants.TeleportFlags.ViaLogin) != 0;
+    
+                CheckHeartbeat();
+    
+                sp = GetScenePresence(client.AgentId);
 
-                // The first agent upon login is a root agent by design.
-                // For this agent we will have to rez the attachments.
-                // All other AddNewClient calls find aCircuit.child to be true.
-                if (aCircuit.child == false)
+                // XXX: Not sure how good it is to add a new client if a scene presence already exists.  Possibly this
+                // could occur if a viewer crashes and relogs before the old client is kicked out.  But this could cause
+                // other problems, and possible the code calling AddNewClient() should ensure that no client is already
+                // connected.
+                if (sp == null)
                 {
-                    // We have to set SP to be a root agent here so that SP.MakeRootAgent() will later not try to
-                    // start the scripts again (since this is done in RezAttachments()).
-                    // XXX: This is convoluted.
-                    sp.IsChildAgent = false;
-
-                    if (AttachmentsModule != null)
-                        Util.FireAndForget(delegate(object o) { AttachmentsModule.RezAttachments(sp); });
+                    m_log.DebugFormat(
+                        "[SCENE]: Adding new child scene presence {0} {1} to scene {2} at pos {3}",
+                        client.Name, client.AgentId, RegionInfo.RegionName, client.StartPos);
+    
+                    m_clientManager.Add(client);
+                    SubscribeToClientEvents(client);
+    
+                    sp = m_sceneGraph.CreateAndAddChildScenePresence(client, aCircuit.Appearance, type);
+                    m_eventManager.TriggerOnNewPresence(sp);
+    
+                    sp.TeleportFlags = (TPFlags)aCircuit.teleportFlags;
+    
+                    // The first agent upon login is a root agent by design.
+                    // For this agent we will have to rez the attachments.
+                    // All other AddNewClient calls find aCircuit.child to be true.
+                    if (aCircuit.child == false)
+                    {
+                        // We have to set SP to be a root agent here so that SP.MakeRootAgent() will later not try to
+                        // start the scripts again (since this is done in RezAttachments()).
+                        // XXX: This is convoluted.
+                        sp.IsChildAgent = false;
+    
+                        if (AttachmentsModule != null)
+                            Util.FireAndForget(delegate(object o) { AttachmentsModule.RezAttachments(sp); });
+                    }
                 }
-            }
-            else
-            {
-                m_log.WarnFormat(
-                    "[SCENE]: Already found {0} scene presence for {1} in {2} when asked to add new scene presence",
-                    sp.IsChildAgent ? "child" : "root", sp.Name, RegionInfo.RegionName);
-            }
+                else
+                {
+                    m_log.WarnFormat(
+                        "[SCENE]: Already found {0} scene presence for {1} in {2} when asked to add new scene presence",
+                        sp.IsChildAgent ? "child" : "root", sp.Name, RegionInfo.RegionName);
+                }
+    
+                // We must set this here so that TriggerOnNewClient and TriggerOnClientLogin can determine whether the
+                // client is for a root or child agent.
+                client.SceneAgent = sp;
 
-            // We must set this here so that TriggerOnNewClient and TriggerOnClientLogin can determine whether the
-            // client is for a root or child agent.
-            client.SceneAgent = sp;
+                // Cache the user's name
+                CacheUserName(sp, aCircuit);
+    
+                EventManager.TriggerOnNewClient(client);
+                if (vialogin)
+                    EventManager.TriggerOnClientLogin(client);
+            }
 
             m_LastLogin = Util.EnvironmentTickCount();
 
-            // Cache the user's name
-            CacheUserName(sp, aCircuit);
-
-            EventManager.TriggerOnNewClient(client);
-            if (vialogin)
-            {
-                EventManager.TriggerOnClientLogin(client);
-                // Send initial parcel data
-/* this is done on TriggerOnNewClient by landmanegement respective event handler
-                Vector3 pos = sp.AbsolutePosition;
-                ILandObject land = LandChannel.GetLandObject(pos.X, pos.Y);
-                land.SendLandUpdateToClient(client);
-*/
-            }
-
             return sp;
         }
 
@@ -3439,110 +3539,131 @@ namespace OpenSim.Region.Framework.Scenes
         {
 //            CheckHeartbeat();
             bool isChildAgent = false;
-            ScenePresence avatar = GetScenePresence(agentID);
-
-            if (avatar == null)
-            {
-                m_log.WarnFormat(
-                    "[SCENE]: Called RemoveClient() with agent ID {0} but no such presence is in the scene.", agentID);
+            AgentCircuitData acd;
 
-                return;
-            }
-
-            try
+            lock (m_removeClientLock)
             {
-                isChildAgent = avatar.IsChildAgent;
+                acd = m_authenticateHandler.GetAgentCircuitData(agentID);
 
-                m_log.DebugFormat(
-                    "[SCENE]: Removing {0} agent {1} {2} from {3}",
-                    (isChildAgent ? "child" : "root"), avatar.Name, agentID, RegionInfo.RegionName);
-
-                // Don't do this to root agents, it's not nice for the viewer
-                if (closeChildAgents && isChildAgent)
+                if (acd == null)
                 {
-                    // Tell a single agent to disconnect from the region.
-                    IEventQueue eq = RequestModuleInterface<IEventQueue>();
-                    if (eq != null)
-                    {
-                        eq.DisableSimulator(RegionInfo.RegionHandle, avatar.UUID);
-                    }
-                    else
-                    {
-                        avatar.ControllingClient.SendShutdownConnectionNotice();
-                    }
+                    m_log.ErrorFormat("[SCENE]: No agent circuit found for {0}, aborting Scene.RemoveClient", agentID);
+                    return;
                 }
-
-                // Only applies to root agents.
-                if (avatar.ParentID != 0)
+                else
                 {
-                    avatar.StandUp();
+                    // We remove the acd up here to avoid later raec conditions if two RemoveClient() calls occurred
+                    // simultaneously.
+                    m_authenticateHandler.RemoveCircuit(acd.circuitcode);
                 }
+            }
 
-                m_sceneGraph.removeUserCount(!isChildAgent);
-
-                // TODO: We shouldn't use closeChildAgents here - it's being used by the NPC module to stop
-                // unnecessary operations.  This should go away once NPCs have no accompanying IClientAPI
-                if (closeChildAgents && CapsModule != null)
-                    CapsModule.RemoveCaps(agentID);
-
-                // REFACTORING PROBLEM -- well not really a problem, but just to point out that whatever
-                // this method is doing is HORRIBLE!!!
-                avatar.Scene.NeedSceneCacheClear(avatar.UUID);
-
-                if (closeChildAgents && !isChildAgent)
+            lock (acd)
+            {
+                ScenePresence avatar = GetScenePresence(agentID);
+    
+                if (avatar == null)
                 {
-                    List<ulong> regions = avatar.KnownRegionHandles;
-                    regions.Remove(RegionInfo.RegionHandle);
-                    m_sceneGridService.SendCloseChildAgentConnections(agentID, regions);
+                    m_log.WarnFormat(
+                        "[SCENE]: Called RemoveClient() with agent ID {0} but no such presence is in the scene.", agentID);
+    
+                    return;
                 }
-
-                m_eventManager.TriggerClientClosed(agentID, this);
-                m_eventManager.TriggerOnRemovePresence(agentID);
-
-                if (!isChildAgent)
+    
+                try
                 {
-                    if (AttachmentsModule != null)
+                    isChildAgent = avatar.IsChildAgent;
+
+                    m_log.DebugFormat(
+                        "[SCENE]: Removing {0} agent {1} {2} from {3}",
+                        (isChildAgent ? "child" : "root"), avatar.Name, agentID, RegionInfo.RegionName);
+    
+                    // Don't do this to root agents, it's not nice for the viewer
+                    if (closeChildAgents && isChildAgent)
+                    {
+                        // Tell a single agent to disconnect from the region.
+                        IEventQueue eq = RequestModuleInterface<IEventQueue>();
+                        if (eq != null)
+                        {
+                            eq.DisableSimulator(RegionInfo.RegionHandle, avatar.UUID);
+                        }
+                        else
+                        {
+                            avatar.ControllingClient.SendShutdownConnectionNotice();
+                        }
+                    }
+    
+                    // Only applies to root agents.
+                    if (avatar.ParentID != 0)
                     {
-                        AttachmentsModule.DeRezAttachments(avatar);
+                        avatar.StandUp();
                     }
-
-                    ForEachClient(
-                        delegate(IClientAPI client)
+    
+                    m_sceneGraph.removeUserCount(!isChildAgent);
+    
+                    // TODO: We shouldn't use closeChildAgents here - it's being used by the NPC module to stop
+                    // unnecessary operations.  This should go away once NPCs have no accompanying IClientAPI
+                    if (closeChildAgents && CapsModule != null)
+                        CapsModule.RemoveCaps(agentID);
+    
+//                    // REFACTORING PROBLEM -- well not really a problem, but just to point out that whatever
+//                    // this method is doing is HORRIBLE!!!
+                    // Commented pending deletion since this method no longer appears to do anything at all
+//                    avatar.Scene.NeedSceneCacheClear(avatar.UUID);
+    
+                    if (closeChildAgents && !isChildAgent)
+                    {
+                        List<ulong> regions = avatar.KnownRegionHandles;
+                        regions.Remove(RegionInfo.RegionHandle);
+                        m_sceneGridService.SendCloseChildAgentConnections(agentID, regions);
+                    }
+    
+                    m_eventManager.TriggerClientClosed(agentID, this);
+                    m_eventManager.TriggerOnRemovePresence(agentID);
+    
+                    if (!isChildAgent)
+                    {
+                        if (AttachmentsModule != null)
                         {
-                            //We can safely ignore null reference exceptions.  It means the avatar is dead and cleaned up anyway
-                            try { client.SendKillObject(avatar.RegionHandle, new List<uint> { avatar.LocalId }); }
-                            catch (NullReferenceException) { }
-                        });
-                }
-
-                // It's possible for child agents to have transactions if changes are being made cross-border.
-                if (AgentTransactionsModule != null)
-                    AgentTransactionsModule.RemoveAgentAssetTransactions(agentID);
+                            AttachmentsModule.DeRezAttachments(avatar);
+                        }
 
-                m_authenticateHandler.RemoveCircuit(avatar.ControllingClient.CircuitCode);
-                m_log.Debug("[Scene] The avatar has left the building");
-            }
-            catch (Exception e)
-            {
-                m_log.Error(
-                    string.Format("[SCENE]: Exception removing {0} from {1}.  Cleaning up.  Exception ", avatar.Name, Name), e);
-            }
-            finally
-            {
-                try
-                {
-                    // Always clean these structures up so that any failure above doesn't cause them to remain in the
-                    // scene with possibly bad effects (e.g. continually timing out on unacked packets and triggering
-                    // the same cleanup exception continually.
-                    m_sceneGraph.RemoveScenePresence(agentID);
-                    m_clientManager.Remove(agentID);
+                        ForEachClient(
+                            delegate(IClientAPI client)
+                            {
+                                //We can safely ignore null reference exceptions.  It means the avatar is dead and cleaned up anyway
+                                try { client.SendKillObject(avatar.RegionHandle, new List<uint> { avatar.LocalId }); }
+                                catch (NullReferenceException) { }
+                            });
+                    }
     
-                    avatar.Close();
+                    // It's possible for child agents to have transactions if changes are being made cross-border.
+                    if (AgentTransactionsModule != null)
+                        AgentTransactionsModule.RemoveAgentAssetTransactions(agentID);
+                    m_log.Debug("[Scene] The avatar has left the building");
                 }
                 catch (Exception e)
                 {
                     m_log.Error(
-                        string.Format("[SCENE]: Exception in final clean up of {0} in {1}.  Exception ", avatar.Name, Name), e);
+                        string.Format("[SCENE]: Exception removing {0} from {1}.  Cleaning up.  Exception ", avatar.Name, Name), e);
+                }
+                finally
+                {
+                    try
+                    {
+                        // Always clean these structures up so that any failure above doesn't cause them to remain in the
+                        // scene with possibly bad effects (e.g. continually timing out on unacked packets and triggering
+                        // the same cleanup exception continually.
+                        m_sceneGraph.RemoveScenePresence(agentID);
+                        m_clientManager.Remove(agentID);
+        
+                        avatar.Close();
+                    }
+                    catch (Exception e)
+                    {
+                        m_log.Error(
+                            string.Format("[SCENE]: Exception in final clean up of {0} in {1}.  Exception ", avatar.Name, Name), e);
+                    }
                 }
             }
 
@@ -3601,11 +3722,9 @@ namespace OpenSim.Region.Framework.Scenes
 
         /// <summary>
         /// Do the work necessary to initiate a new user connection for a particular scene.
-        /// At the moment, this consists of setting up the caps infrastructure
-        /// The return bool should allow for connections to be refused, but as not all calling paths
-        /// take proper notice of it let, we allowed banned users in still.
         /// </summary>
         /// <param name="agent">CircuitData of the agent who is connecting</param>
+        /// <param name="teleportFlags"></param>
         /// <param name="reason">Outputs the reason for the false response on this string</param>
         /// <returns>True if the region accepts this agent.  False if it does not.  False will 
         /// also return a reason.</returns>
@@ -3616,10 +3735,20 @@ namespace OpenSim.Region.Framework.Scenes
 
         /// <summary>
         /// Do the work necessary to initiate a new user connection for a particular scene.
-        /// At the moment, this consists of setting up the caps infrastructure
+        /// </summary>
+        /// <remarks>
+        /// The return bool should allow for connections to be refused, but as not all calling paths
+        /// take proper notice of it yet, we still allowed banned users in.
+        ///
+        /// At the moment this method consists of setting up the caps infrastructure
         /// The return bool should allow for connections to be refused, but as not all calling paths
         /// take proper notice of it let, we allowed banned users in still.
-        /// </summary>
+        ///
+        /// This method is called by the login service (in the case of login) or another simulator (in the case of region
+        /// cross or teleport) to initiate the connection.  It is not triggered by the viewer itself - the connection
+        /// is activated later when the viewer sends the initial UseCircuitCodePacket UDP packet (in the case of
+        /// the LLUDP stack).
+        /// </remarks>
         /// <param name="agent">CircuitData of the agent who is connecting</param>
         /// <param name="reason">Outputs the reason for the false response on this string</param>
         /// <param name="requirePresenceLookup">True for normal presence. False for NPC
@@ -3718,83 +3847,86 @@ namespace OpenSim.Region.Framework.Scenes
                     "[SCENE]: Existing root scene presence detected for {0} {1} in {2} when connecting.  Removing existing presence.",
                     sp.Name, sp.UUID, RegionInfo.RegionName);
 
-                sp.ControllingClient.Close();
+                sp.ControllingClient.Close(true, true);
                 sp = null;
             }
 
-
-            //On login test land permisions
-            if (vialogin)
+            lock (agent)
             {
-                IUserAccountCacheModule cache = RequestModuleInterface<IUserAccountCacheModule>();
-                if (cache != null)
-                    cache.Remove(agent.firstname + " " + agent.lastname);
-                if (!TestLandRestrictions(agent.AgentID, out reason, ref agent.startpos.X, ref agent.startpos.Y))
+                //On login test land permisions
+                if (vialogin)
                 {
-                    m_log.DebugFormat("[CONNECTION BEGIN]: Denying access to {0} due to no land access", agent.AgentID.ToString());
-                    return false;
+                    IUserAccountCacheModule cache = RequestModuleInterface<IUserAccountCacheModule>();
+                    if (cache != null)
+                        cache.Remove(agent.firstname + " " + agent.lastname);
+                    if (!TestLandRestrictions(agent.AgentID, out reason, ref agent.startpos.X, ref agent.startpos.Y))
+                    {
+                        m_log.DebugFormat("[CONNECTION BEGIN]: Denying access to {0} due to no land access", agent.AgentID.ToString());
+                        return false;
+                    }
                 }
-            }
 
-            if (sp == null) // We don't have an [child] agent here already
-            {
-                if (requirePresenceLookup)
+                if (sp == null) // We don't have an [child] agent here already
                 {
-                    try
+                    if (requirePresenceLookup)
                     {
-                        if (!VerifyUserPresence(agent, out reason))
+                        try
+                        {
+                            if (!VerifyUserPresence(agent, out reason))
+                                return false;
+                        } catch (Exception e)
+                        {
+                            m_log.ErrorFormat(
+                                "[SCENE]: Exception verifying presence {0}{1}", e.Message, e.StackTrace);
                             return false;
-                    } catch (Exception e)
+                        }
+                    }
+
+                    try
+                    {
+                        // Always check estate if this is a login. Always
+                        // check if banned regions are to be blacked out.
+                        if (vialogin || (!m_seeIntoBannedRegion))
+                        {
+                            if (!AuthorizeUser(agent, out reason))
+                                return false;
+                        }
+                    }
+                    catch (Exception e)
                     {
                         m_log.ErrorFormat(
-                            "[SCENE]: Exception verifying presence {0}{1}", e.Message, e.StackTrace);
+                            "[SCENE]: Exception authorizing user {0}{1}", e.Message, e.StackTrace);
                         return false;
                     }
-                }
 
-                try
-                {
-                    // Always check estate if this is a login. Always
-                    // check if banned regions are to be blacked out.
-                    if (vialogin || (!m_seeIntoBannedRegion))
+                    m_log.InfoFormat(
+                        "[SCENE]: Region {0} authenticated and authorized incoming {1} agent {2} {3} {4} (circuit code {5})",
+                        RegionInfo.RegionName, (agent.child ? "child" : "root"), agent.firstname, agent.lastname,
+                        agent.AgentID, agent.circuitcode);
+
+                    if (CapsModule != null)
                     {
-                        if (!AuthorizeUser(agent, out reason))
-                            return false;
+                        CapsModule.SetAgentCapsSeeds(agent);
+                        CapsModule.CreateCaps(agent.AgentID);
                     }
                 }
-                catch (Exception e)
+                else
                 {
-                    m_log.ErrorFormat(
-                        "[SCENE]: Exception authorizing user {0}{1}", e.Message, e.StackTrace);
-                    return false;
-                }
+                    // Let the SP know how we got here. This has a lot of interesting
+                    // uses down the line.
+                    sp.TeleportFlags = (TPFlags)teleportFlags;
 
-                m_log.InfoFormat(
-                    "[SCENE]: Region {0} authenticated and authorized incoming {1} agent {2} {3} {4} (circuit code {5})",
-                    RegionInfo.RegionName, (agent.child ? "child" : "root"), agent.firstname, agent.lastname,
-                    agent.AgentID, agent.circuitcode);
-
-                if (CapsModule != null)
-                {
-                    CapsModule.SetAgentCapsSeeds(agent);
-                    CapsModule.CreateCaps(agent.AgentID);
-                }
-            } else
-            {
-                // Let the SP know how we got here. This has a lot of interesting
-                // uses down the line.
-                sp.TeleportFlags = (TPFlags)teleportFlags;
+                    if (sp.IsChildAgent)
+                    {
+                        m_log.DebugFormat(
+                            "[SCENE]: Adjusting known seeds for existing agent {0} in {1}",
+                            agent.AgentID, RegionInfo.RegionName);
 
-                if (sp.IsChildAgent)
-                {
-                    m_log.DebugFormat(
-                        "[SCENE]: Adjusting known seeds for existing agent {0} in {1}",
-                        agent.AgentID, RegionInfo.RegionName);
+                        sp.AdjustKnownSeeds();
 
-                    sp.AdjustKnownSeeds();
-                    
-                    if (CapsModule != null)
-                        CapsModule.SetAgentCapsSeeds(agent);
+                        if (CapsModule != null)
+                            CapsModule.SetAgentCapsSeeds(agent);
+                    }
                 }
             }
 
@@ -4225,8 +4357,9 @@ namespace OpenSim.Region.Framework.Scenes
                 return false;
             }
 
-            // We have to wait until the viewer contacts this region after receiving EAC.
-            // That calls AddNewClient, which finally creates the ScenePresence
+            // We have to wait until the viewer contacts this region
+            // after receiving the EnableSimulator HTTP Event Queue message.  This triggers the viewer to send
+            // a UseCircuitCode packet which in turn calls AddNewClient which finally creates the ScenePresence.
             ScenePresence childAgentUpdate = WaitGetScenePresence(cAgentData.AgentID);
 
             if (childAgentUpdate != null)
@@ -4321,15 +4454,18 @@ namespace OpenSim.Region.Framework.Scenes
         /// Tell a single agent to disconnect from the region.
         /// </summary>
         /// <param name="agentID"></param>
-        /// <param name="childOnly"></param>
-        public bool IncomingCloseAgent(UUID agentID, bool childOnly)
+        /// <param name="force">
+        /// Force the agent to close even if it might be in the middle of some other operation.  You do not want to
+        /// force unless you are absolutely sure that the agent is dead and a normal close is not working.
+        /// </param>
+        public bool IncomingCloseAgent(UUID agentID, bool force)
         {
             //m_log.DebugFormat("[SCENE]: Processing incoming close agent for {0}", agentID);
 
             ScenePresence presence = m_sceneGraph.GetScenePresence(agentID);
             if (presence != null)
             {
-                presence.ControllingClient.Close(false);
+                presence.ControllingClient.Close(force, force);
                 return true;
             }
 
@@ -4535,6 +4671,16 @@ namespace OpenSim.Region.Framework.Scenes
             return LandChannel.GetLandObject(x, y).LandData;
         }
 
+        /// <summary>
+        /// Get LandData by position.
+        /// </summary>
+        /// <param name="pos"></param>
+        /// <returns></returns>
+        public LandData GetLandData(Vector3 pos)
+        {
+            return GetLandData(pos.X, pos.Y);
+        }
+
         public LandData GetLandData(uint x, uint y)
         {
             m_log.DebugFormat("[SCENE]: returning land for {0},{1}", x, y);
@@ -4765,13 +4911,24 @@ namespace OpenSim.Region.Framework.Scenes
         /// Get a group via its UUID
         /// </summary>
         /// <param name="fullID"></param>
-        /// <returns>null if no group with that name exists</returns>
+        /// <returns>null if no group with that id exists</returns>
         public SceneObjectGroup GetSceneObjectGroup(UUID fullID)
         {
             return m_sceneGraph.GetSceneObjectGroup(fullID);
         }
 
         /// <summary>
+        /// Get a group via its local ID
+        /// </summary>
+        /// <remarks>This will only return a group if the local ID matches a root part</remarks>
+        /// <param name="localID"></param>
+        /// <returns>null if no group with that id exists</returns>
+        public SceneObjectGroup GetSceneObjectGroup(uint localID)
+        {
+            return m_sceneGraph.GetSceneObjectGroup(localID);
+        }
+
+        /// <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>
@@ -4783,6 +4940,18 @@ namespace OpenSim.Region.Framework.Scenes
         }
 
         /// <summary>
+        /// Attempt to get the SOG via its UUID
+        /// </summary>
+        /// <param name="fullID"></param>
+        /// <param name="sog"></param>
+        /// <returns></returns>
+        public bool TryGetSceneObjectGroup(UUID fullID, out SceneObjectGroup sog)
+        {
+            sog = GetSceneObjectGroup(fullID);
+            return sog != null;
+        }
+
+        /// <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>
@@ -4814,6 +4983,18 @@ namespace OpenSim.Region.Framework.Scenes
         }
 
         /// <summary>
+        /// Attempt to get a prim via its UUID
+        /// </summary>
+        /// <param name="fullID"></param>
+        /// <param name="sop"></param>
+        /// <returns></returns>
+        public bool TryGetSceneObjectPart(UUID fullID, out SceneObjectPart sop)
+        {
+            sop = GetSceneObjectPart(fullID);
+            return sop != null;
+        }
+
+        /// <summary>
         /// Get a scene object group that contains the prim with the given local id
         /// </summary>
         /// <param name="localID"></param>
@@ -4907,14 +5088,15 @@ namespace OpenSim.Region.Framework.Scenes
                 client.SendRegionHandle(regionID, handle);
         }
 
-        public bool NeedSceneCacheClear(UUID agentID)
-        {
-            IInventoryTransferModule inv = RequestModuleInterface<IInventoryTransferModule>();
-            if (inv == null)
-                return true;
-
-            return inv.NeedSceneCacheClear(agentID, this);
-        }
+// Commented pending deletion since this method no longer appears to do anything at all
+//        public bool NeedSceneCacheClear(UUID agentID)
+//        {
+//            IInventoryTransferModule inv = RequestModuleInterface<IInventoryTransferModule>();
+//            if (inv == null)
+//                return true;
+//
+//            return inv.NeedSceneCacheClear(agentID, this);
+//        }
 
         public void CleanTempObjects()
         {
@@ -5868,6 +6050,9 @@ Environment.Exit(1);
 
         public string GetExtraSetting(string name)
         {
+            if (m_extraSettings == null)
+                return String.Empty;
+
             string val;
 
             if (!m_extraSettings.TryGetValue(name, out val))
@@ -5878,6 +6063,9 @@ Environment.Exit(1);
 
         public void StoreExtraSetting(string name, string val)
         {
+            if (m_extraSettings == null)
+                return;
+
             string oldVal;
 
             if (m_extraSettings.TryGetValue(name, out oldVal))
@@ -5895,6 +6083,9 @@ Environment.Exit(1);
 
         public void RemoveExtraSetting(string name)
         {
+            if (m_extraSettings == null)
+                return;
+
             if (!m_extraSettings.ContainsKey(name))
                 return;
 
diff --git a/OpenSim/Region/Framework/Scenes/SceneGraph.cs b/OpenSim/Region/Framework/Scenes/SceneGraph.cs
index af13b46..e599e90 100644
--- a/OpenSim/Region/Framework/Scenes/SceneGraph.cs
+++ b/OpenSim/Region/Framework/Scenes/SceneGraph.cs
@@ -342,7 +342,7 @@ namespace OpenSim.Region.Framework.Scenes
         public bool AddNewSceneObject(
             SceneObjectGroup sceneObject, bool attachToBackup, Vector3? pos, Quaternion? rot, Vector3 vel)
         {
-            AddNewSceneObject(sceneObject, true, false);
+            AddNewSceneObject(sceneObject, attachToBackup, false);
 
             if (pos != null)
                 sceneObject.AbsolutePosition = (Vector3)pos;
@@ -421,12 +421,9 @@ namespace OpenSim.Region.Framework.Scenes
                 {
                     Vector3 scale = part.Shape.Scale;
 
-                    if (scale.X > m_parentScene.m_maxNonphys)
-                        scale.X = m_parentScene.m_maxNonphys;
-                    if (scale.Y > m_parentScene.m_maxNonphys)
-                        scale.Y = m_parentScene.m_maxNonphys;
-                    if (scale.Z > m_parentScene.m_maxNonphys)
-                        scale.Z = m_parentScene.m_maxNonphys;
+                    scale.X = Math.Max(m_parentScene.m_minNonphys, Math.Min(m_parentScene.m_maxNonphys, scale.X));
+                    scale.Y = Math.Max(m_parentScene.m_minNonphys, Math.Min(m_parentScene.m_maxNonphys, scale.Y));
+                    scale.Z = Math.Max(m_parentScene.m_minNonphys, Math.Min(m_parentScene.m_maxNonphys, scale.Z));
 
                     part.Shape.Scale = scale;
                 }
@@ -1066,6 +1063,30 @@ namespace OpenSim.Region.Framework.Scenes
         }
 
         /// <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>
diff --git a/OpenSim/Region/Framework/Scenes/SceneManager.cs b/OpenSim/Region/Framework/Scenes/SceneManager.cs
index f1b09ca..dba3a61 100644
--- a/OpenSim/Region/Framework/Scenes/SceneManager.cs
+++ b/OpenSim/Region/Framework/Scenes/SceneManager.cs
@@ -92,7 +92,11 @@ namespace OpenSim.Region.Framework.Scenes
         private static SceneManager m_instance = null;
         public static SceneManager Instance
         { 
-            get { return m_instance; } 
+            get {
+                if (m_instance == null)
+                    m_instance = new SceneManager();
+                return m_instance;
+            } 
         }
 
         private readonly DoubleDictionary<UUID, string, Scene> m_localScenes = new DoubleDictionary<UUID, string, Scene>();
diff --git a/OpenSim/Region/Framework/Scenes/SceneObjectGroup.cs b/OpenSim/Region/Framework/Scenes/SceneObjectGroup.cs
index ee61de6..74d2629 100644
--- a/OpenSim/Region/Framework/Scenes/SceneObjectGroup.cs
+++ b/OpenSim/Region/Framework/Scenes/SceneObjectGroup.cs
@@ -2747,6 +2747,25 @@ namespace OpenSim.Region.Framework.Scenes
             if (objectGroup == this)
                 return;
 
+            // If the configured linkset capacity is greater than zero,
+            // and the new linkset would have a prim count higher than this
+            // value, do not link it.
+            if (m_scene.m_linksetCapacity > 0 &&
+                    (PrimCount + objectGroup.PrimCount) >
+                    m_scene.m_linksetCapacity)
+            {
+                m_log.DebugFormat(
+                    "[SCENE OBJECT GROUP]: Cannot link group with root" +
+                    " part {0}, {1} ({2} prims) to group with root part" +
+                    " {3}, {4} ({5} prims) because the new linkset" +
+                    " would exceed the configured maximum of {6}",
+                    objectGroup.RootPart.Name, objectGroup.RootPart.UUID,
+                    objectGroup.PrimCount, RootPart.Name, RootPart.UUID,
+                    PrimCount, m_scene.m_linksetCapacity);
+
+                return;
+            }
+
             // 'linkPart' == the root of the group being linked into this group
             SceneObjectPart linkPart = objectGroup.m_rootPart;
 
@@ -3492,27 +3511,33 @@ namespace OpenSim.Region.Framework.Scenes
         /// <param name="scale"></param>
         public void GroupResize(Vector3 scale)
         {
-            scale.X = Math.Min(scale.X, Scene.m_maxNonphys);
-            scale.Y = Math.Min(scale.Y, Scene.m_maxNonphys);
-            scale.Z = Math.Min(scale.Z, Scene.m_maxNonphys);
+//            m_log.DebugFormat(
+//                "[SCENE OBJECT GROUP]: Group resizing {0} {1} from {2} to {3}", Name, LocalId, RootPart.Scale, scale);
 
             PhysicsActor pa = m_rootPart.PhysActor;
 
-            if (pa != null && pa.IsPhysical)
+            if (Scene != null)
             {
-                scale.X = Math.Min(scale.X, Scene.m_maxPhys);
-                scale.Y = Math.Min(scale.Y, Scene.m_maxPhys);
-                scale.Z = Math.Min(scale.Z, Scene.m_maxPhys);
+                scale.X = Math.Max(Scene.m_minNonphys, Math.Min(Scene.m_maxNonphys, scale.X));
+                scale.Y = Math.Max(Scene.m_minNonphys, Math.Min(Scene.m_maxNonphys, scale.Y));
+                scale.Z = Math.Max(Scene.m_minNonphys, Math.Min(Scene.m_maxNonphys, scale.Z));
+    
+                if (pa != null && pa.IsPhysical)
+                {
+                    scale.X = Math.Max(Scene.m_minPhys, Math.Min(Scene.m_maxPhys, scale.X));
+                    scale.Y = Math.Max(Scene.m_minPhys, Math.Min(Scene.m_maxPhys, scale.Y));
+                    scale.Z = Math.Max(Scene.m_minPhys, Math.Min(Scene.m_maxPhys, scale.Z));
+                }
             }
 
             float x = (scale.X / RootPart.Scale.X);
             float y = (scale.Y / RootPart.Scale.Y);
             float z = (scale.Z / RootPart.Scale.Z);
 
-            SceneObjectPart[] parts;
-            if (x > 1.0f || y > 1.0f || z > 1.0f)
+            SceneObjectPart[] parts = m_parts.GetArray();
+
+            if (Scene != null & (x > 1.0f || y > 1.0f || z > 1.0f))
             {
-                parts = m_parts.GetArray();
                 for (int i = 0; i < parts.Length; i++)
                 {
                     SceneObjectPart obPart = parts[i];
@@ -3525,7 +3550,7 @@ namespace OpenSim.Region.Framework.Scenes
 
                         if (pa != null && pa.IsPhysical)
                         {
-                            if (oldSize.X * x > m_scene.m_maxPhys)
+                            if (oldSize.X * x > Scene.m_maxPhys)
                             {
                                 f = m_scene.m_maxPhys / oldSize.X;
                                 a = f / x;
@@ -3533,8 +3558,16 @@ namespace OpenSim.Region.Framework.Scenes
                                 y *= a;
                                 z *= a;
                             }
+                            else if (oldSize.X * x < Scene.m_minPhys)
+                            {
+                                f = m_scene.m_minPhys / oldSize.X;
+                                a = f / x;
+                                x *= a;
+                                y *= a;
+                                z *= a;
+                            }
 
-                            if (oldSize.Y * y > m_scene.m_maxPhys)
+                            if (oldSize.Y * y > Scene.m_maxPhys)
                             {
                                 f = m_scene.m_maxPhys / oldSize.Y;
                                 a = f / y;
@@ -3542,8 +3575,16 @@ namespace OpenSim.Region.Framework.Scenes
                                 y *= a;
                                 z *= a;
                             }
+                            else if (oldSize.Y * y < Scene.m_minPhys)
+                            {
+                                f = m_scene.m_minPhys / oldSize.Y;
+                                a = f / y;
+                                x *= a;
+                                y *= a;
+                                z *= a;
+                            }
 
-                            if (oldSize.Z * z > m_scene.m_maxPhys)
+                            if (oldSize.Z * z > Scene.m_maxPhys)
                             {
                                 f = m_scene.m_maxPhys / oldSize.Z;
                                 a = f / z;
@@ -3551,10 +3592,18 @@ namespace OpenSim.Region.Framework.Scenes
                                 y *= a;
                                 z *= a;
                             }
+                            else if (oldSize.Z * z < Scene.m_minPhys)
+                            {
+                                f = m_scene.m_minPhys / oldSize.Z;
+                                a = f / z;
+                                x *= a;
+                                y *= a;
+                                z *= a;
+                            }
                         }
                         else
                         {
-                            if (oldSize.X * x > m_scene.m_maxNonphys)
+                            if (oldSize.X * x > Scene.m_maxNonphys)
                             {
                                 f = m_scene.m_maxNonphys / oldSize.X;
                                 a = f / x;
@@ -3562,8 +3611,16 @@ namespace OpenSim.Region.Framework.Scenes
                                 y *= a;
                                 z *= a;
                             }
+                            else if (oldSize.X * x < Scene.m_minNonphys)
+                            {
+                                f = m_scene.m_minNonphys / oldSize.X;
+                                a = f / x;
+                                x *= a;
+                                y *= a;
+                                z *= a;
+                            }
 
-                            if (oldSize.Y * y > m_scene.m_maxNonphys)
+                            if (oldSize.Y * y > Scene.m_maxNonphys)
                             {
                                 f = m_scene.m_maxNonphys / oldSize.Y;
                                 a = f / y;
@@ -3571,8 +3628,16 @@ namespace OpenSim.Region.Framework.Scenes
                                 y *= a;
                                 z *= a;
                             }
+                            else if (oldSize.Y * y < Scene.m_minNonphys)
+                            {
+                                f = m_scene.m_minNonphys / oldSize.Y;
+                                a = f / y;
+                                x *= a;
+                                y *= a;
+                                z *= a;
+                            }
 
-                            if (oldSize.Z * z > m_scene.m_maxNonphys)
+                            if (oldSize.Z * z > Scene.m_maxNonphys)
                             {
                                 f = m_scene.m_maxNonphys / oldSize.Z;
                                 a = f / z;
@@ -3580,6 +3645,14 @@ namespace OpenSim.Region.Framework.Scenes
                                 y *= a;
                                 z *= a;
                             }
+                            else if (oldSize.Z * z < Scene.m_minNonphys)
+                            {
+                                f = m_scene.m_minNonphys / oldSize.Z;
+                                a = f / z;
+                                x *= a;
+                                y *= a;
+                                z *= a;
+                            }
                         }
                     }
                 }
@@ -3592,7 +3665,6 @@ namespace OpenSim.Region.Framework.Scenes
 
             RootPart.Resize(prevScale);
 
-            parts = m_parts.GetArray();
             for (int i = 0; i < parts.Length; i++)
             {
                 SceneObjectPart obPart = parts[i];
diff --git a/OpenSim/Region/Framework/Scenes/SceneObjectPart.cs b/OpenSim/Region/Framework/Scenes/SceneObjectPart.cs
index 49b771f..248679b 100644
--- a/OpenSim/Region/Framework/Scenes/SceneObjectPart.cs
+++ b/OpenSim/Region/Framework/Scenes/SceneObjectPart.cs
@@ -790,7 +790,7 @@ namespace OpenSim.Region.Framework.Scenes
                     }
                     catch (Exception e)
                     {
-                        m_log.Error("[SCENEOBJECTPART]: GROUP POSITION. " + e.Message);
+                        m_log.ErrorFormat("[SCENEOBJECTPART]: GROUP POSITION. {0}", e);
                     }
                 }
             }
@@ -2979,17 +2979,20 @@ namespace OpenSim.Region.Framework.Scenes
         /// <param name="scale"></param>
         public void Resize(Vector3 scale)
         {
-            scale.X = Math.Min(scale.X, ParentGroup.Scene.m_maxNonphys);
-            scale.Y = Math.Min(scale.Y, ParentGroup.Scene.m_maxNonphys);
-            scale.Z = Math.Min(scale.Z, ParentGroup.Scene.m_maxNonphys);
-
             PhysicsActor pa = PhysActor;
 
-            if (pa != null && pa.IsPhysical)
+            if (ParentGroup.Scene != null)
             {
-                scale.X = Math.Min(scale.X, ParentGroup.Scene.m_maxPhys);
-                scale.Y = Math.Min(scale.Y, ParentGroup.Scene.m_maxPhys);
-                scale.Z = Math.Min(scale.Z, ParentGroup.Scene.m_maxPhys);
+                scale.X = Math.Max(ParentGroup.Scene.m_minNonphys, Math.Min(ParentGroup.Scene.m_maxNonphys, scale.X));
+                scale.Y = Math.Max(ParentGroup.Scene.m_minNonphys, Math.Min(ParentGroup.Scene.m_maxNonphys, scale.Y));
+                scale.Z = Math.Max(ParentGroup.Scene.m_minNonphys, Math.Min(ParentGroup.Scene.m_maxNonphys, scale.Z));
+    
+                if (pa != null && pa.IsPhysical)
+                {
+                    scale.X = Math.Max(ParentGroup.Scene.m_minPhys, Math.Min(ParentGroup.Scene.m_maxPhys, scale.X));
+                    scale.Y = Math.Max(ParentGroup.Scene.m_minPhys, Math.Min(ParentGroup.Scene.m_maxPhys, scale.Y));
+                    scale.Z = Math.Max(ParentGroup.Scene.m_minPhys, Math.Min(ParentGroup.Scene.m_maxPhys, scale.Z));
+                }
             }
 
 //            m_log.DebugFormat("[SCENE OBJECT PART]: Resizing {0} {1} to {2}", Name, LocalId, scale);
@@ -3086,7 +3089,7 @@ namespace OpenSim.Region.Framework.Scenes
             //                UUID, Name, TimeStampFull);
 
             if (ParentGroup.Scene != null)
-                ParentGroup.Scene.EventManager.TriggerSceneObjectPartUpdated(this);
+                ParentGroup.Scene.EventManager.TriggerSceneObjectPartUpdated(this, true);
         }
 
         /// <summary>
@@ -3120,7 +3123,7 @@ namespace OpenSim.Region.Framework.Scenes
             }
 
             if (ParentGroup.Scene != null)
-                ParentGroup.Scene.EventManager.TriggerSceneObjectPartUpdated(this);
+                ParentGroup.Scene.EventManager.TriggerSceneObjectPartUpdated(this, false);
         }
 
         public void ScriptSetPhysicsStatus(bool UsePhysics)
@@ -3575,23 +3578,32 @@ namespace OpenSim.Region.Framework.Scenes
         }
 
         /// <summary>
-        /// Set the color of prim faces
+        /// Set the color & alpha of prim faces
         /// </summary>
-        /// <param name="color"></param>
         /// <param name="face"></param>
-        public void SetFaceColor(Vector3 color, int face)
+        /// <param name="color"></param>
+        /// <param name="alpha"></param>
+        public void SetFaceColorAlpha(int face, Vector3 color, double ?alpha)
         {
+            Vector3 clippedColor = Util.Clip(color, 0.0f, 1.0f);
+            float clippedAlpha = alpha.HasValue ?
+                Util.Clip((float)alpha.Value, 0.0f, 1.0f) : 0;
+
             // The only way to get a deep copy/ If we don't do this, we can
-            // mever detect color changes further down.
+            // never detect color changes further down.
             Byte[] buf = Shape.Textures.GetBytes();
             Primitive.TextureEntry tex = new Primitive.TextureEntry(buf, 0, buf.Length);
             Color4 texcolor;
             if (face >= 0 && face < GetNumberOfSides())
             {
                 texcolor = tex.CreateFace((uint)face).RGBA;
-                texcolor.R = Util.Clip((float)color.X, 0.0f, 1.0f);
-                texcolor.G = Util.Clip((float)color.Y, 0.0f, 1.0f);
-                texcolor.B = Util.Clip((float)color.Z, 0.0f, 1.0f);
+                texcolor.R = clippedColor.X;
+                texcolor.G = clippedColor.Y;
+                texcolor.B = clippedColor.Z;
+                if (alpha.HasValue)
+                {
+                    texcolor.A = clippedAlpha;
+                }
                 tex.FaceTextures[face].RGBA = texcolor;
                 UpdateTextureEntry(tex.GetBytes());
                 return;
@@ -3603,15 +3615,23 @@ namespace OpenSim.Region.Framework.Scenes
                     if (tex.FaceTextures[i] != null)
                     {
                         texcolor = tex.FaceTextures[i].RGBA;
-                        texcolor.R = Util.Clip((float)color.X, 0.0f, 1.0f);
-                        texcolor.G = Util.Clip((float)color.Y, 0.0f, 1.0f);
-                        texcolor.B = Util.Clip((float)color.Z, 0.0f, 1.0f);
+                        texcolor.R = clippedColor.X;
+                        texcolor.G = clippedColor.Y;
+                        texcolor.B = clippedColor.Z;
+                        if (alpha.HasValue)
+                        {
+                            texcolor.A = clippedAlpha;
+                        }
                         tex.FaceTextures[i].RGBA = texcolor;
                     }
                     texcolor = tex.DefaultTexture.RGBA;
-                    texcolor.R = Util.Clip((float)color.X, 0.0f, 1.0f);
-                    texcolor.G = Util.Clip((float)color.Y, 0.0f, 1.0f);
-                    texcolor.B = Util.Clip((float)color.Z, 0.0f, 1.0f);
+                    texcolor.R = clippedColor.X;
+                    texcolor.G = clippedColor.Y;
+                    texcolor.B = clippedColor.Z;
+                    if (alpha.HasValue)
+                    {
+                        texcolor.A = clippedAlpha;
+                    }
                     tex.DefaultTexture.RGBA = texcolor;
                 }
                 UpdateTextureEntry(tex.GetBytes());
@@ -4899,6 +4919,57 @@ namespace OpenSim.Region.Framework.Scenes
             ScheduleFullUpdate();
         }
 
+        public void UpdateSlice(float begin, float end)
+        {
+            if (end < begin)
+            {
+                float temp = begin;
+                begin = end;
+                end = temp;
+            }
+            end = Math.Min(1f, Math.Max(0f, end));
+            begin = Math.Min(Math.Min(1f, Math.Max(0f, begin)), end - 0.02f);
+            if (begin < 0.02f && end < 0.02f)
+            {
+                begin = 0f;
+                end = 0.02f;
+            }
+
+            ushort uBegin = (ushort)(50000.0 * begin);
+            ushort uEnd = (ushort)(50000.0 * (1f - end));
+            bool updatePossiblyNeeded = false;
+            PrimType primType = GetPrimType();
+            if (primType == PrimType.SPHERE || primType == PrimType.TORUS || primType == PrimType.TUBE || primType == PrimType.RING)
+            {
+                if (m_shape.ProfileBegin != uBegin || m_shape.ProfileEnd != uEnd)
+                {
+                    m_shape.ProfileBegin = uBegin;
+                    m_shape.ProfileEnd = uEnd;
+                    updatePossiblyNeeded = true;
+                }
+            }
+            else if (m_shape.PathBegin != uBegin || m_shape.PathEnd != uEnd)
+            {
+                m_shape.PathBegin = uBegin;
+                m_shape.PathEnd = uEnd;
+                updatePossiblyNeeded = true;
+            }
+
+            if (updatePossiblyNeeded && ParentGroup != null)
+            {
+                ParentGroup.HasGroupChanged = true;
+            }
+            if (updatePossiblyNeeded && PhysActor != null)
+            {
+                PhysActor.Shape = m_shape;
+                ParentGroup.Scene.PhysicsScene.AddPhysicsActorTaint(PhysActor);
+            }
+            if (updatePossiblyNeeded)
+            {
+                ScheduleFullUpdate();
+            }
+        }
+
         /// <summary>
         /// If the part is a sculpt/mesh, retrieve the mesh data and reinsert it into the shape so that the physics
         /// engine can use it.
diff --git a/OpenSim/Region/Framework/Scenes/SceneObjectPartInventory.cs b/OpenSim/Region/Framework/Scenes/SceneObjectPartInventory.cs
index e010864..f41e329 100644
--- a/OpenSim/Region/Framework/Scenes/SceneObjectPartInventory.cs
+++ b/OpenSim/Region/Framework/Scenes/SceneObjectPartInventory.cs
@@ -97,6 +97,15 @@ namespace OpenSim.Region.Framework.Scenes
                 QueryScriptStates();
             }
         }
+
+        public int Count
+        {
+            get
+            {
+                lock (m_items)
+                    return m_items.Count;
+            }
+        }
         
         /// <summary>
         /// Constructor
diff --git a/OpenSim/Region/Framework/Scenes/ScenePresence.cs b/OpenSim/Region/Framework/Scenes/ScenePresence.cs
index a8aa551..870bd66 100644
--- a/OpenSim/Region/Framework/Scenes/ScenePresence.cs
+++ b/OpenSim/Region/Framework/Scenes/ScenePresence.cs
@@ -69,7 +69,7 @@ namespace OpenSim.Region.Framework.Scenes
         public ScriptControlled eventControls;
     }
 
-    public delegate void SendCourseLocationsMethod(UUID scene, ScenePresence presence, List<Vector3> coarseLocations, List<UUID> avatarUUIDs);
+    public delegate void SendCoarseLocationsMethod(UUID scene, ScenePresence presence, List<Vector3> coarseLocations, List<UUID> avatarUUIDs);
 
     public class ScenePresence : EntityBase, IScenePresence
     {
@@ -188,7 +188,7 @@ namespace OpenSim.Region.Framework.Scenes
         /// </summary>
         public bool SitGround { get; private set; }
 
-        private SendCourseLocationsMethod m_sendCourseLocationsMethod;
+        private SendCoarseLocationsMethod m_sendCoarseLocationsMethod;
 
         //private Vector3 m_requestedSitOffset = new Vector3();
 
@@ -711,7 +711,7 @@ namespace OpenSim.Region.Framework.Scenes
             AttachmentsSyncLock = new Object();
             AllowMovement = true;
             IsChildAgent = true;
-            m_sendCourseLocationsMethod = SendCoarseLocationsDefault;
+            m_sendCoarseLocationsMethod = SendCoarseLocationsDefault;
             Animator = new ScenePresenceAnimator(this);
             PresenceType = type;
             DrawDistance = world.DefaultDrawDistance;
@@ -974,7 +974,9 @@ namespace OpenSim.Region.Framework.Scenes
             {
                 if (wasChild && HasAttachments())
                 {
-                    m_log.DebugFormat("[SCENE PRESENCE]: Restarting scripts in attachments...");
+                    m_log.DebugFormat(
+                        "[SCENE PRESENCE]: Restarting scripts in attachments for {0} in {1}", Name, Scene.Name);
+                    
                     // Resume scripts
                     Util.FireAndForget(delegate(object x) {
                         foreach (SceneObjectGroup sog in m_attachments)
@@ -1530,17 +1532,22 @@ namespace OpenSim.Region.Framework.Scenes
                 bool DCFlagKeyPressed = false;
                 Vector3 agent_control_v3 = Vector3.Zero;
 
-                bool oldflying = Flying;
+                bool newFlying = actor.Flying;
 
                 if (ForceFly)
-                    actor.Flying = true;
+                    newFlying = true;
                 else if (FlyDisabled)
-                    actor.Flying = false;
+                    newFlying = false;
                 else
-                    actor.Flying = ((flags & AgentManager.ControlFlags.AGENT_CONTROL_FLY) != 0);
+                    newFlying = ((flags & AgentManager.ControlFlags.AGENT_CONTROL_FLY) != 0);
 
-                if (actor.Flying != oldflying)
+                if (actor.Flying != newFlying)
+                {
+                    // Note: ScenePresence.Flying is actually fetched from the physical actor
+                    //     so setting PhysActor.Flying here also sets the ScenePresence's value.
+                    actor.Flying = newFlying;
                     update_movementflag = true;
+                }
 
                 if (ParentID == 0)
                 {
@@ -2622,17 +2629,17 @@ namespace OpenSim.Region.Framework.Scenes
 
         public void SendCoarseLocations(List<Vector3> coarseLocations, List<UUID> avatarUUIDs)
         {
-            SendCourseLocationsMethod d = m_sendCourseLocationsMethod;
+            SendCoarseLocationsMethod d = m_sendCoarseLocationsMethod;
             if (d != null)
             {
                 d.Invoke(m_scene.RegionInfo.originRegionID, this, coarseLocations, avatarUUIDs);
             }
         }
 
-        public void SetSendCourseLocationMethod(SendCourseLocationsMethod d)
+        public void SetSendCoarseLocationMethod(SendCoarseLocationsMethod d)
         {
             if (d != null)
-                m_sendCourseLocationsMethod = d;
+                m_sendCoarseLocationsMethod = d;
         }
 
         public void SendCoarseLocationsDefault(UUID sceneId, ScenePresence p, List<Vector3> coarseLocations, List<UUID> avatarUUIDs)
@@ -2836,7 +2843,7 @@ namespace OpenSim.Region.Framework.Scenes
         #region Significant Movement Method
 
         /// <summary>
-        /// This checks for a significant movement and sends a courselocationchange update
+        /// This checks for a significant movement and sends a coarselocationchange update
         /// </summary>
         protected void CheckForSignificantMovement()
         {
@@ -3268,7 +3275,7 @@ namespace OpenSim.Region.Framework.Scenes
                 cAgent.Anims = Animator.Animations.ToArray();
             }
             catch { }
-            cAgent.DefaultAnim = Animator.Animations.DefaultAnimation;
+            cAgent.DefaultAnim = Animator.Animations.ImplicitDefaultAnimation;
 
             if (Scene.AttachmentsModule != null)
                 Scene.AttachmentsModule.CopyAttachments(this, cAgent);
@@ -3627,13 +3634,16 @@ namespace OpenSim.Region.Framework.Scenes
         public List<SceneObjectGroup> GetAttachments(uint attachmentPoint)
         {
             List<SceneObjectGroup> attachments = new List<SceneObjectGroup>();
-            
-            lock (m_attachments)
+
+            if (attachmentPoint >= 0)
             {
-                foreach (SceneObjectGroup so in m_attachments)
+                lock (m_attachments)
                 {
-                    if (attachmentPoint == so.AttachmentPoint)
-                        attachments.Add(so);
+                    foreach (SceneObjectGroup so in m_attachments)
+                    {
+                        if (attachmentPoint == so.AttachmentPoint)
+                            attachments.Add(so);
+                    }
                 }
             }
             
diff --git a/OpenSim/Region/Framework/Scenes/SimStatsReporter.cs b/OpenSim/Region/Framework/Scenes/SimStatsReporter.cs
index 756b1f4..5398ab9 100644
--- a/OpenSim/Region/Framework/Scenes/SimStatsReporter.cs
+++ b/OpenSim/Region/Framework/Scenes/SimStatsReporter.cs
@@ -47,6 +47,7 @@ namespace OpenSim.Region.Framework.Scenes
             = log4net.LogManager.GetLogger(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType);
 
         public const string LastReportedObjectUpdateStatName = "LastReportedObjectUpdates";
+        public const string SlowFramesStatName = "SlowFrames";
 
         public delegate void SendStatResult(SimStats stats);
 
@@ -129,6 +130,16 @@ namespace OpenSim.Region.Framework.Scenes
         }
 
         /// <summary>
+        /// Number of frames that have taken longer to process than Scene.MIN_FRAME_TIME
+        /// </summary>
+        public Stat SlowFramesStat { get; private set; }
+
+        /// <summary>
+        /// The threshold at which we log a slow frame.
+        /// </summary>
+        public int SlowFramesStatReportThreshold { get; private set; }
+
+        /// <summary>
         /// Extra sim statistics that are used by monitors but not sent to the client.
         /// </summary>
         /// <value>
@@ -226,6 +237,24 @@ namespace OpenSim.Region.Framework.Scenes
 
             if (StatsManager.SimExtraStats != null)
                 OnSendStatsResult += StatsManager.SimExtraStats.ReceiveClassicSimStatsPacket;
+
+            /// At the moment, we'll only report if a frame is over 120% of target, since commonly frames are a bit
+            /// longer than ideal (which in itself is a concern).
+            SlowFramesStatReportThreshold = (int)Math.Ceiling(m_scene.MinFrameTime * 1000 * 1.2);
+
+            SlowFramesStat
+                = new Stat(
+                    "SlowFrames",
+                    "Slow Frames",
+                    "Number of frames where frame time has been significantly longer than the desired frame time.",
+                    " frames",
+                    "scene",
+                    m_scene.Name,
+                    StatType.Push,
+                    null,
+                    StatVerbosity.Info);
+
+            StatsManager.RegisterStat(SlowFramesStat);
         }
 
         public void Close()
@@ -443,6 +472,7 @@ namespace OpenSim.Region.Framework.Scenes
                     lock (m_lastReportedExtraSimStats)
                     {
                         m_lastReportedExtraSimStats[LastReportedObjectUpdateStatName] = m_objectUpdates / m_statsUpdateFactor;
+                        m_lastReportedExtraSimStats[SlowFramesStat.ShortName] = (float)SlowFramesStat.Value;
 
                         Dictionary<string, float> physicsStats = m_scene.PhysicsScene.GetStats();
         
@@ -563,6 +593,11 @@ namespace OpenSim.Region.Framework.Scenes
         public void addFrameMS(int ms)
         {
             m_frameMS += ms;
+
+            // At the moment, we'll only report if a frame is over 120% of target, since commonly frames are a bit
+            // longer than ideal due to the inaccuracy of the Sleep in Scene.Update() (which in itself is a concern).
+            if (ms > SlowFramesStatReportThreshold)
+                SlowFramesStat.Value++;
         }
 
         public void addNetMS(int ms)
diff --git a/OpenSim/Region/Framework/Scenes/Tests/ScenePresenceAgentTests.cs b/OpenSim/Region/Framework/Scenes/Tests/ScenePresenceAgentTests.cs
index 5758869..5faf131 100644
--- a/OpenSim/Region/Framework/Scenes/Tests/ScenePresenceAgentTests.cs
+++ b/OpenSim/Region/Framework/Scenes/Tests/ScenePresenceAgentTests.cs
@@ -141,7 +141,7 @@ namespace OpenSim.Region.Framework.Scenes.Tests
             TestScene scene = new SceneHelpers().SetupScene();
             ScenePresence sp = SceneHelpers.AddScenePresence(scene, TestHelpers.ParseTail(0x1));
 
-            scene.IncomingCloseAgent(sp.UUID);
+            scene.IncomingCloseAgent(sp.UUID, false);
 
             Assert.That(scene.GetScenePresence(sp.UUID), Is.Null);
             Assert.That(scene.AuthenticateHandler.GetAgentCircuitData(sp.UUID), Is.Null);
diff --git a/OpenSim/Region/Framework/Scenes/Tests/SceneTests.cs b/OpenSim/Region/Framework/Scenes/Tests/SceneTests.cs
index d722a09..ac3da1e 100644
--- a/OpenSim/Region/Framework/Scenes/Tests/SceneTests.cs
+++ b/OpenSim/Region/Framework/Scenes/Tests/SceneTests.cs
@@ -65,5 +65,22 @@ namespace OpenSim.Region.Framework.Scenes.Tests
             
             Assert.That(scene.Frame, Is.EqualTo(1));
         }
+
+        [Test]
+        public void TestShutdownScene()
+        {
+            TestHelpers.InMethod();
+
+            Scene scene = new SceneHelpers().SetupScene();
+            scene.Close();
+
+            Assert.That(scene.ShuttingDown, Is.True);
+            Assert.That(scene.Active, Is.False);
+
+            // Trying to update a shutdown scene should result in no update
+            scene.Update(1);
+
+            Assert.That(scene.Frame, Is.EqualTo(0));
+        }
     }
 }
\ No newline at end of file
diff --git a/OpenSim/Region/Framework/Scenes/Tests/UserInventoryTests.cs b/OpenSim/Region/Framework/Scenes/Tests/UserInventoryTests.cs
index 44d2d45..9457ebb 100644
--- a/OpenSim/Region/Framework/Scenes/Tests/UserInventoryTests.cs
+++ b/OpenSim/Region/Framework/Scenes/Tests/UserInventoryTests.cs
@@ -50,9 +50,41 @@ using OpenSim.Tests.Common.Mock;
 namespace OpenSim.Region.Framework.Tests
 {
     [TestFixture]
-    public class UserInventoryTests
+    public class UserInventoryTests : OpenSimTestCase
     {
         [Test]
+        public void TestCreateInventoryFolders()
+        {
+            TestHelpers.InMethod();
+//            TestHelpers.EnableLogging();
+
+            // For this test both folders will have the same name which is legal in SL user inventories.
+            string foldersName = "f1";
+
+            Scene scene = new SceneHelpers().SetupScene();
+            UserAccount user1 = UserAccountHelpers.CreateUserWithInventory(scene, TestHelpers.ParseTail(1001));
+
+            UserInventoryHelpers.CreateInventoryFolder(scene.InventoryService, user1.PrincipalID, foldersName);
+
+            List<InventoryFolderBase> oneFolder
+                = UserInventoryHelpers.GetInventoryFolders(scene.InventoryService, user1.PrincipalID, foldersName);
+
+            Assert.That(oneFolder.Count, Is.EqualTo(1));
+            InventoryFolderBase firstRetrievedFolder = oneFolder[0];
+            Assert.That(firstRetrievedFolder.Name, Is.EqualTo(foldersName));
+
+            UserInventoryHelpers.CreateInventoryFolder(scene.InventoryService, user1.PrincipalID, foldersName);
+
+            List<InventoryFolderBase> twoFolders
+                = UserInventoryHelpers.GetInventoryFolders(scene.InventoryService, user1.PrincipalID, foldersName);
+
+            Assert.That(twoFolders.Count, Is.EqualTo(2));
+            Assert.That(twoFolders[0].Name, Is.EqualTo(foldersName));
+            Assert.That(twoFolders[1].Name, Is.EqualTo(foldersName));
+            Assert.That(twoFolders[0].ID, Is.Not.EqualTo(twoFolders[1].ID));
+        }
+
+        [Test]
         public void TestGiveInventoryItem()
         {
             TestHelpers.InMethod();
@@ -83,7 +115,7 @@ namespace OpenSim.Region.Framework.Tests
         public void TestGiveInventoryFolder()
         {
             TestHelpers.InMethod();
-//            log4net.Config.XmlConfigurator.Configure();
+//            TestHelpers.EnableLogging();
             
             Scene scene = new SceneHelpers().SetupScene();
             UserAccount user1 = UserAccountHelpers.CreateUserWithInventory(scene, TestHelpers.ParseTail(1001));
diff --git a/OpenSim/Region/Framework/Scenes/UuidGatherer.cs b/OpenSim/Region/Framework/Scenes/UuidGatherer.cs
index 411e421..2279e62 100644
--- a/OpenSim/Region/Framework/Scenes/UuidGatherer.cs
+++ b/OpenSim/Region/Framework/Scenes/UuidGatherer.cs
@@ -52,26 +52,23 @@ namespace OpenSim.Region.Framework.Scenes
     public class UuidGatherer
     {
         private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
-        
-        /// <summary>
-        /// Asset cache used for gathering assets
-        /// </summary>
-        protected IAssetService m_assetCache;
-        
-        /// <summary>
-        /// Used as a temporary store of an asset which represents an object.  This can be a null if no appropriate
-        /// asset was found by the asset service.
-        /// </summary>
-        private AssetBase m_requestedObjectAsset;
 
-        /// <summary>
-        /// Signal whether we are currently waiting for the asset service to deliver an asset.
-        /// </summary>
-        private bool m_waitingForObjectAsset;
+        protected IAssetService m_assetService;
+
+//        /// <summary>
+//        /// Used as a temporary store of an asset which represents an object.  This can be a null if no appropriate
+//        /// asset was found by the asset service.
+//        /// </summary>
+//        private AssetBase m_requestedObjectAsset;
+//
+//        /// <summary>
+//        /// Signal whether we are currently waiting for the asset service to deliver an asset.
+//        /// </summary>
+//        private bool m_waitingForObjectAsset;
                 
-        public UuidGatherer(IAssetService assetCache)
+        public UuidGatherer(IAssetService assetService)
         {
-            m_assetCache = assetCache;
+            m_assetService = assetService;
         }
                 
         /// <summary>
@@ -191,18 +188,18 @@ namespace OpenSim.Region.Framework.Scenes
             }
         }
         
-        /// <summary>
-        /// The callback made when we request the asset for an object from the asset service.
-        /// </summary>
-        private void AssetReceived(string id, Object sender, AssetBase asset)
-        {
-            lock (this)
-            {
-                m_requestedObjectAsset = asset;
-                m_waitingForObjectAsset = false;
-                Monitor.Pulse(this);
-            }
-        }
+//        /// <summary>
+//        /// The callback made when we request the asset for an object from the asset service.
+//        /// </summary>
+//        private void AssetReceived(string id, Object sender, AssetBase asset)
+//        {
+//            lock (this)
+//            {
+//                m_requestedObjectAsset = asset;
+//                m_waitingForObjectAsset = false;
+//                Monitor.Pulse(this);
+//            }
+//        }
 
         /// <summary>
         /// Get an asset synchronously, potentially using an asynchronous callback.  If the
@@ -212,25 +209,29 @@ namespace OpenSim.Region.Framework.Scenes
         /// <returns></returns>
         protected virtual AssetBase GetAsset(UUID uuid)
         {
-            m_waitingForObjectAsset = true;
-            m_assetCache.Get(uuid.ToString(), this, AssetReceived);
-
-            // The asset cache callback can either
-            //
-            // 1. Complete on the same thread (if the asset is already in the cache) or
-            // 2. Come in via a different thread (if we need to go fetch it).
-            //
-            // The code below handles both these alternatives.
-            lock (this)
-            {
-                if (m_waitingForObjectAsset)
-                {
-                    Monitor.Wait(this);
-                    m_waitingForObjectAsset = false;
-                }
-            }
+            return m_assetService.Get(uuid.ToString());
 
-            return m_requestedObjectAsset;
+            // XXX: Switching to do this synchronously where the call was async before but we always waited for it
+            // to complete anyway!
+//            m_waitingForObjectAsset = true;
+//            m_assetCache.Get(uuid.ToString(), this, AssetReceived);
+//
+//            // The asset cache callback can either
+//            //
+//            // 1. Complete on the same thread (if the asset is already in the cache) or
+//            // 2. Come in via a different thread (if we need to go fetch it).
+//            //
+//            // The code below handles both these alternatives.
+//            lock (this)
+//            {
+//                if (m_waitingForObjectAsset)
+//                {
+//                    Monitor.Wait(this);
+//                    m_waitingForObjectAsset = false;
+//                }
+//            }
+//
+//            return m_requestedObjectAsset;
         }
 
         /// <summary>
@@ -361,4 +362,47 @@ namespace OpenSim.Region.Framework.Scenes
             }
         }
     }
+
+    public class HGUuidGatherer : UuidGatherer
+    {
+        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+
+        protected string m_assetServerURL;
+
+        public HGUuidGatherer(IAssetService assetService, string assetServerURL)
+            : base(assetService)
+        {
+            m_assetServerURL = assetServerURL;
+            if (!m_assetServerURL.EndsWith("/") && !m_assetServerURL.EndsWith("="))
+                m_assetServerURL = m_assetServerURL + "/";
+        }
+
+        protected override AssetBase GetAsset(UUID uuid)
+        {
+            if (string.Empty == m_assetServerURL)
+                return base.GetAsset(uuid);
+            else
+                return FetchAsset(uuid);
+        }
+
+        public AssetBase FetchAsset(UUID assetID)
+        {
+
+            // Test if it's already here
+            AssetBase asset = m_assetService.Get(assetID.ToString());
+            if (asset == null)
+            {
+                // It's not, so fetch it from abroad
+                asset = m_assetService.Get(m_assetServerURL + assetID.ToString());
+                if (asset != null)
+                    m_log.DebugFormat("[HGUUIDGatherer]: Copied asset {0} from {1} to local asset server", assetID, m_assetServerURL);
+                else
+                    m_log.DebugFormat("[HGUUIDGatherer]: Failed to fetch asset {0} from {1}", assetID, m_assetServerURL);
+            }
+            //else
+            //    m_log.DebugFormat("[HGUUIDGatherer]: Asset {0} from {1} was already here", assetID, m_assetServerURL);
+
+            return asset;
+        }
+    }
 }