26 files changed, 1805 insertions, 566 deletions
diff --git a/OpenSim/Region/Framework/Interfaces/IAttachmentsModule.cs b/OpenSim/Region/Framework/Interfaces/IAttachmentsModule.cs
index 90a13a7..d781eae 100644
--- a/OpenSim/Region/Framework/Interfaces/IAttachmentsModule.cs
+++ b/OpenSim/Region/Framework/Interfaces/IAttachmentsModule.cs
@@ -114,6 +114,15 @@ namespace OpenSim.Region.Framework.Interfaces
        void DetachSingleAttachmentToGround(IScenePresence sp, uint objectLocalID);
        /// <summary>
+        /// Detach the given item to the ground at the specified coordinates & rotation
+        /// </summary>
+        /// <param name="sp"></param>
+        /// <param name="objectLocalID"></param>
+        /// <param name="absolutePos"></param>
+        /// <param name="absoluteRot"></param>
+        void DetachSingleAttachmentToGround(IScenePresence sp, uint objectLocalID, Vector3 absolutePos, Quaternion absoluteRot);
+        /// <summary>
        /// Detach the given attachment so that it remains in the user's inventory.
        /// </summary>
        /// <param name="sp">/param>
diff --git a/OpenSim/Region/Framework/Interfaces/IDynamicTextureManager.cs b/OpenSim/Region/Framework/Interfaces/IDynamicTextureManager.cs
index 8954513..6df5cc2 100644
--- a/OpenSim/Region/Framework/Interfaces/IDynamicTextureManager.cs
+++ b/OpenSim/Region/Framework/Interfaces/IDynamicTextureManager.cs
@@ -25,6 +25,8 @@
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
+using System;
+using System.Drawing;
 using System.IO;
 using OpenMetaverse;
@@ -33,7 +35,14 @@ namespace OpenSim.Region.Framework.Interfaces
    public interface IDynamicTextureManager
    {
        void RegisterRender(string handleType, IDynamicTextureRender render);
-        void ReturnData(UUID id, byte[] data);
+        /// <summary>
+        /// Used by IDynamicTextureRender implementations to return renders
+        /// </summary>
+        /// <param name='id'></param>
+        /// <param name='data'></param>
+        /// <param name='isReuseable'></param>
+        void ReturnData(UUID id, IDynamicTexture texture);
        UUID AddDynamicTextureURL(UUID simID, UUID primID, string contentType, string url, string extraParams,
                                    int updateTimer);
@@ -113,11 +122,65 @@ namespace OpenSim.Region.Framework.Interfaces
        string GetName();
        string GetContentType();
        bool SupportsAsynchronous();
-        byte[] ConvertUrl(string url, string extraParams);
-        byte[] ConvertStream(Stream data, string extraParams);
+//        /// <summary>
+//        /// Return true if converting the input body and extra params data will always result in the same byte[] array
+//        /// </summary>
+//        /// <remarks>
+//        /// This method allows the caller to use a previously generated asset if it has one.
+//        /// </remarks>
+//        /// <returns></returns>
+//        /// <param name='bodyData'></param>
+//        /// <param name='extraParams'></param>
+//        bool AlwaysIdenticalConversion(string bodyData, string extraParams);
+        IDynamicTexture ConvertUrl(string url, string extraParams);
+        IDynamicTexture ConvertData(string bodyData, string extraParams);
        bool AsyncConvertUrl(UUID id, string url, string extraParams);
        bool AsyncConvertData(UUID id, string bodyData, string extraParams);
        void GetDrawStringSize(string text, string fontName, int fontSize, 
                               out double xSize, out double ySize);
    }
+    public interface IDynamicTexture
+    {
+        /// <summary>
+        /// Input commands used to generate this data.
+        /// </summary>
+        /// <remarks>
+        /// Null if input commands were not used.
+        /// </remarks>
+        string InputCommands { get; }
+        /// <summary>
+        /// Uri used to generate this data.
+        /// </summary>
+        /// <remarks>
+        /// Null if a uri was not used.
+        /// </remarks>
+        Uri InputUri { get; }
+        /// <summary>
+        /// Extra input params used to generate this data.
+        /// </summary>
+        string InputParams { get; }
+        /// <summary>
+        /// Texture data.
+        /// </summary>
+        byte[] Data { get; }
+        /// <summary>
+        /// Size of texture.
+        /// </summary>
+        Size Size { get; }
+        /// <summary>
+        /// Signal whether the texture is reuseable (i.e. whether the same input data will always generate the same
+        /// texture).
+        /// </summary>
+        bool IsReuseable { get; }
+    }
 }
diff --git a/OpenSim/Region/Framework/Interfaces/IEntityInventory.cs b/OpenSim/Region/Framework/Interfaces/IEntityInventory.cs
index 4274cbe..8028d87 100644
--- a/OpenSim/Region/Framework/Interfaces/IEntityInventory.cs
+++ b/OpenSim/Region/Framework/Interfaces/IEntityInventory.cs
@@ -152,6 +152,19 @@ namespace OpenSim.Region.Framework.Interfaces
        void StopScriptInstance(UUID itemId);
        /// <summary>
+        /// Try to get the script running status.
+        /// </summary>
+        /// <returns>
+        /// Returns true if a script for the item was found in one of the simulator's script engines.  In this case,
+        /// the running parameter will reflect the running status.
+        /// Returns false if the item could not be found, if the item is not a script or if a script instance for the
+        /// item was not found in any of the script engines.  In this case, running status is irrelevant.
+        /// </returns>
+        /// <param name='itemId'></param>
+        /// <param name='running'></param>
+        bool TryGetScriptInstanceRunning(UUID itemId, out bool running);
+        /// <summary>
        /// Add an item to this entity's inventory.  If an item with the same name already exists, then an alternative
        /// name is chosen.
        /// </summary>
@@ -270,17 +283,25 @@ namespace OpenSim.Region.Framework.Interfaces
        void ApplyGodPermissions(uint perms);
        /// <summary>
+        /// Number of items in this inventory.
+        /// </summary>
+        int Count { get; }
+        /// <summary>
        /// Returns true if this inventory contains any scripts
        /// </summary></returns>
        bool ContainsScripts();
        /// <summary>
-        /// Returns the count of scripts contained
+        /// Number of scripts in this inventory.
-        /// </summary></returns>
+        /// </summary>
+        /// <remarks>
+        /// Includes both running and non running scripts.
+        /// </remarks>
        int ScriptCount();
        /// <summary>
-        /// Returns the count of running scripts contained
+        /// Number of running scripts in this inventory.
        /// </summary></returns>
        int RunningScriptCount();
diff --git a/OpenSim/Region/Framework/Interfaces/IEstateModule.cs b/OpenSim/Region/Framework/Interfaces/IEstateModule.cs
index ca2ad94..292efa4 100644
--- a/OpenSim/Region/Framework/Interfaces/IEstateModule.cs
+++ b/OpenSim/Region/Framework/Interfaces/IEstateModule.cs
@@ -46,6 +46,10 @@ namespace OpenSim.Region.Framework.Interfaces
        /// </summary>
        void sendRegionHandshakeToAll();
        void TriggerEstateInfoChange();
+        /// <summary>
+        /// Fires the OnRegionInfoChange event.
+        /// </summary>
        void TriggerRegionInfoChange();
        void setEstateTerrainBaseTexture(int level, UUID texture);
diff --git a/OpenSim/Region/Framework/Interfaces/IJsonStoreModule.cs b/OpenSim/Region/Framework/Interfaces/IJsonStoreModule.cs
index baac6e8..da39e95 100644
--- a/OpenSim/Region/Framework/Interfaces/IJsonStoreModule.cs
+++ b/OpenSim/Region/Framework/Interfaces/IJsonStoreModule.cs
@@ -35,7 +35,7 @@ namespace OpenSim.Region.Framework.Interfaces
    public interface IJsonStoreModule
    {
-        bool CreateStore(string value, out UUID result);
+        bool CreateStore(string value, ref UUID result);
        bool DestroyStore(UUID storeID);
        bool TestPath(UUID storeID, string path, bool useJson);
        bool SetValue(UUID storeID, string path, string value, bool useJson);
diff --git a/OpenSim/Region/Framework/Interfaces/IScriptModuleComms.cs b/OpenSim/Region/Framework/Interfaces/IScriptModuleComms.cs
index a76ffde..70ff954 100644
--- a/OpenSim/Region/Framework/Interfaces/IScriptModuleComms.cs
+++ b/OpenSim/Region/Framework/Interfaces/IScriptModuleComms.cs
@@ -47,9 +47,46 @@ namespace OpenSim.Region.Framework.Interfaces
        /// </summary>
        event ScriptCommand OnScriptCommand;
+        /// <summary>
+        /// Register an instance method as a script call by method name
+        /// </summary>
+        /// <param name="target"></param>
+        /// <param name="method"></param>
        void RegisterScriptInvocation(object target, string method);
+        /// <summary>
+        /// Register a static or instance method as a script call by method info
+        /// </summary>
+        /// <param name="target">If target is a Type object, will assume method is static.</param>
+        /// <param name="method"></param>
        void RegisterScriptInvocation(object target, MethodInfo method);
+        /// <summary>
+        /// Register one or more instance methods as script calls by method name
+        /// </summary>
+        /// <param name="target"></param>
+        /// <param name="methods"></param>
        void RegisterScriptInvocation(object target, string[] methods);
+        /// <summary>
+        /// Register one or more static methods as script calls by method name
+        /// </summary>
+        /// <param name="target"></param>
+        /// <param name="methods"></param>
+        void RegisterScriptInvocation(Type target, string[] methods);
+        /// <summary>
+        /// Automatically register script invocations by checking for methods
+        /// with <see cref="ScriptInvocationAttribute"/>. Should only check
+        /// public methods.
+        /// </summary>
+        /// <param name="target"></param>
+        void RegisterScriptInvocations(IRegionModuleBase target);
+        /// <summary>
+        /// Returns an array of all registered script calls
+        /// </summary>
+        /// <returns></returns>
        Delegate[] GetScriptInvocationList();
        Delegate LookupScriptInvocation(string fname);
@@ -68,12 +105,44 @@ namespace OpenSim.Region.Framework.Interfaces
        /// <param name="key"></param>
        void DispatchReply(UUID scriptId, int code, string text, string key);
-        /// For constants
+        /// <summary>
+        /// Operation to for a region module to register a constant to be used
+        /// by the script engine
+        /// </summary>
+        /// <param name="cname">
+        /// The name of the constant. LSL convention is for constant names to
+        /// be uppercase.
+        /// </param>
+        /// <param name="value">
+        /// The value of the constant. Should be of a type that can be
+        /// converted to one of <see cref="OpenSim.Region.ScriptEngine.Shared.LSL_Types"/>
+        /// </param>
        void RegisterConstant(string cname, object value);
+        /// <summary>
+        /// Automatically register all constants on a region module by
+        /// checking for fields with <see cref="ScriptConstantAttribute"/>.
+        /// </summary>
+        /// <param name="target"></param>
+        void RegisterConstants(IRegionModuleBase target);
+        /// <summary>
+        /// Operation to check for a registered constant
+        /// </summary>
+        /// <param name="cname">Name of constant</param>
+        /// <returns>Value of constant or null if none found.</returns>
        object LookupModConstant(string cname);
        Dictionary<string, object> GetConstants();
        // For use ONLY by the script API
        void RaiseEvent(UUID script, string id, string module, string command, string key);
    }
+    [AttributeUsage(AttributeTargets.Method)]
+    public class ScriptInvocationAttribute : Attribute
+    { }
+    [AttributeUsage(AttributeTargets.Field)]
+    public class ScriptConstantAttribute : Attribute
+    { }
 }
diff --git a/OpenSim/Region/Framework/Interfaces/ISoundModule.cs b/OpenSim/Region/Framework/Interfaces/ISoundModule.cs
index 6117a80..68af492 100644
--- a/OpenSim/Region/Framework/Interfaces/ISoundModule.cs
+++ b/OpenSim/Region/Framework/Interfaces/ISoundModule.cs
@@ -32,9 +32,96 @@ namespace OpenSim.Region.Framework.Interfaces
 {
    public interface ISoundModule
    {
-        void PlayAttachedSound(UUID soundID, UUID ownerID, UUID objectID, double gain, Vector3 position, byte flags, float radius);
+        /// <summary>
-        
+        /// Maximum distance between a sound source and a recipient.
+        /// </summary>
+        float MaxDistance { get; }
+        /// <summary>
+        /// Play a sound from an object.
+        /// </summary>
+        /// <param name="soundID">Sound asset ID</param>
+        /// <param name="ownerID">Sound source owner</param>
+        /// <param name="objectID">Sound source ID</param>
+        /// <param name="gain">Sound volume</param>
+        /// <param name="position">Sound source position</param>
+        /// <param name="flags">Sound flags</param>
+        /// <param name="radius">
+        /// Radius used to affect gain over distance.
+        /// </param>
+        void PlayAttachedSound(UUID soundID, UUID ownerID, UUID objectID,
+                double gain, Vector3 position, byte flags, float radius);
+        /// <summary>
+        /// Trigger a sound in the scene.
+        /// </summary>
+        /// <param name="soundId">Sound asset ID</param>
+        /// <param name="ownerID">Sound source owner</param>
+        /// <param name="objectID">Sound source ID</param>
+        /// <param name="parentID">Sound source parent.</param>
+        /// <param name="gain">Sound volume</param>
+        /// <param name="position">Sound source position</param>
+        /// <param name="handle"></param>
+        /// <param name="radius">
+        /// Radius used to affect gain over distance.
+        /// </param>
        void TriggerSound(
-            UUID soundId, UUID ownerID, UUID objectID, UUID parentID, double gain, Vector3 position, UInt64 handle, float radius);
+                UUID soundId, UUID ownerID, UUID objectID, UUID parentID,
+                double gain, Vector3 position, UInt64 handle, float radius);
+        /// <summary>
+        /// Stop sounds eminating from an object.
+        /// </summary>
+        /// <param name="objectID">Sound source ID</param>
+        void StopSound(UUID objectID);
+        /// <summary>
+        /// Preload sound to viewers within range.
+        /// </summary>
+        /// <param name="objectID">Sound source ID</param>
+        /// <param name="soundID">Sound asset ID</param>
+        /// <param name="radius">
+        /// Radius used to determine which viewers should preload the sound.
+        /// </param>
+        void PreloadSound(UUID objectID, UUID soundID, float radius);
+        /// <summary>
+        /// Loop specified sound at specified volume with specified radius,
+        /// optionally declaring object as new sync master.
+        /// </summary>
+        /// <param name="objectID">Sound source ID</param>
+        /// <param name="soundID">Sound asset ID</param>
+        /// <param name="gain">Sound volume</param>
+        /// <param name="radius">Sound radius</param>
+        /// <param name="isMaster">Set object to sync master if true</param>
+        void LoopSound(UUID objectID, UUID soundID, double gain,
+                double radius, bool isMaster);
+        /// <summary>
+        /// Trigger or play an attached sound in this part's inventory.
+        /// </summary>
+        /// <param name="objectID">Sound source ID</param>
+        /// <param name="sound">Sound asset ID</param>
+        /// <param name="volume">Sound volume</param>
+        /// <param name="triggered">Triggered or not.</param>
+        /// <param name="flags"></param>
+        /// <param name="radius">Sound radius</param>
+        /// <param name="useMaster">Play using sound master</param>
+        /// <param name="isMaster">Play as sound master</param>
+        void SendSound(UUID objectID, UUID sound, double volume,
+                bool triggered, byte flags, float radius, bool useMaster,
+                bool isMaster);
+        /// <summary>
+        /// Trigger a sound to be played to all agents within an axis-aligned
+        /// bounding box.
+        /// </summary>
+        /// <param name="objectID">Sound source ID</param>
+        /// <param name="sound">Sound asset ID</param>
+        /// <param name="volume">Sound volume</param>
+        /// <param name="min">AABB bottom south-west corner</param>
+        /// <param name="max">AABB top north-east corner</param>
+        void TriggerSoundLimited(UUID objectID, UUID sound, double volume,
+                Vector3 min, Vector3 max);
    }
 }
 \ No newline at end of file
diff --git a/OpenSim/Region/Framework/Interfaces/IUrlModule.cs b/OpenSim/Region/Framework/Interfaces/IUrlModule.cs
index 457444c..79e9f9d 100644
--- a/OpenSim/Region/Framework/Interfaces/IUrlModule.cs
+++ b/OpenSim/Region/Framework/Interfaces/IUrlModule.cs
@@ -39,6 +39,8 @@ namespace OpenSim.Region.Framework.Interfaces
        UUID RequestSecureURL(IScriptModule engine, SceneObjectPart host, UUID itemID);
        void ReleaseURL(string url);
        void HttpResponse(UUID request, int status, string body);
+        void HttpContentType(UUID request, string type);
+        
        string GetHttpHeader(UUID request, string header);
        int GetFreeUrls();
diff --git a/OpenSim/Region/Framework/Interfaces/IUserManagement.cs b/OpenSim/Region/Framework/Interfaces/IUserManagement.cs
index 24cd069..f8088c3 100644
--- a/OpenSim/Region/Framework/Interfaces/IUserManagement.cs
+++ b/OpenSim/Region/Framework/Interfaces/IUserManagement.cs
@@ -1,4 +1,31 @@
-using System;
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSimulator Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+using System;
 using System.Collections.Generic;
 using OpenMetaverse;
diff --git a/OpenSim/Region/Framework/Interfaces/IWorldComm.cs b/OpenSim/Region/Framework/Interfaces/IWorldComm.cs
index e8e375e..20e0199 100644
--- a/OpenSim/Region/Framework/Interfaces/IWorldComm.cs
+++ b/OpenSim/Region/Framework/Interfaces/IWorldComm.cs
@@ -45,6 +45,13 @@ namespace OpenSim.Region.Framework.Interfaces
        void Deactivate();
        void Activate();
        UUID GetID();
+        /// <summary>
+        /// Bitfield indicating which strings should be processed as regex.
+        /// 1 corresponds to IWorldCommListenerInfo::GetName()
+        /// 2 corresponds to IWorldCommListenerInfo::GetMessage()
+        /// </summary>
+        int RegexBitfield { get; }
    }
    public interface IWorldComm
@@ -60,7 +67,7 @@ namespace OpenSim.Region.Framework.Interfaces
        /// the script during 'peek' time. Parameter hostID is needed to
        /// determine the position of the script.
        /// </summary>
-        /// <param name="localID">localID of the script engine</param>
+        /// <param name="LocalID">localID of the script engine</param>
        /// <param name="itemID">UUID of the script engine</param>
        /// <param name="hostID">UUID of the SceneObjectPart</param>
        /// <param name="channel">channel to listen on</param>
@@ -70,6 +77,23 @@ namespace OpenSim.Region.Framework.Interfaces
        /// <returns>number of the scripts handle</returns>
        int Listen(uint LocalID, UUID itemID, UUID hostID, int channel, string name, UUID id, string msg);
+         /// <summary>
+        /// Create a listen event callback with the specified filters.
+        /// The parameters localID,itemID are needed to uniquely identify
+        /// the script during 'peek' time. Parameter hostID is needed to
+        /// determine the position of the script.
+        /// </summary>
+        /// <param name="LocalID">localID of the script engine</param>
+        /// <param name="itemID">UUID of the script engine</param>
+        /// <param name="hostID">UUID of the SceneObjectPart</param>
+        /// <param name="channel">channel to listen on</param>
+        /// <param name="name">name to filter on</param>
+        /// <param name="id">key to filter on (user given, could be totally faked)</param>
+        /// <param name="msg">msg to filter on</param>
+        /// <param name="regexBitfield">Bitfield indicating which strings should be processed as regex.</param>
+        /// <returns>number of the scripts handle</returns>
+        int Listen(uint LocalID, UUID itemID, UUID hostID, int channel, string name, UUID id, string msg, int regexBitfield);
        /// <summary>
        /// This method scans over the objects which registered an interest in listen callbacks.
        /// For everyone it finds, it checks if it fits the given filter. If it does,  then
diff --git a/OpenSim/Region/Framework/Scenes/Animation/AnimationSet.cs b/OpenSim/Region/Framework/Scenes/Animation/AnimationSet.cs
index ad421ee..65ae445 100644
--- a/OpenSim/Region/Framework/Scenes/Animation/AnimationSet.cs
+++ b/OpenSim/Region/Framework/Scenes/Animation/AnimationSet.cs
@@ -41,6 +41,7 @@ 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>();
@@ -49,6 +50,11 @@ namespace OpenSim.Region.Framework.Scenes.Animation
            get { return m_defaultAnimation; } 
        }
        
+        public OpenSim.Framework.Animation ImplicitDefaultAnimation 
+        {
+            get { return m_implicitDefaultAnimation; } 
+        }
+        
        public AnimationSet()
        {
            ResetDefaultAnimation();
@@ -119,11 +125,18 @@ 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;
        }
+        // Called from serialization only
+        public void SetImplicitDefaultAnimation(UUID animID, int sequenceNum, UUID objectID)
+        {
+            m_implicitDefaultAnimation = new OpenSim.Framework.Animation(animID, sequenceNum, objectID);
+        }
        protected bool ResetDefaultAnimation()
        {
            return TrySetDefaultAnimation("STAND", 1, UUID.Zero);
diff --git a/OpenSim/Region/Framework/Scenes/EventManager.cs b/OpenSim/Region/Framework/Scenes/EventManager.cs
index 4a19c3b..5b1c9f4 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 delegate void ScriptTimerEvent(uint localID, double timerinterval);
-//        public event ScriptTimerEvent OnScriptTimerEvent;
+        /// <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;
@@ -436,7 +876,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>
@@ -489,10 +929,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);
@@ -530,9 +973,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
@@ -540,7 +1002,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;
@@ -597,8 +1061,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)
@@ -2035,7 +2520,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");
@@ -2097,7 +2586,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)
@@ -2106,7 +2595,7 @@ namespace OpenSim.Region.Framework.Scenes
                {
                    try
                    {
-                        d(requestId, message);
+                        d(requestId, loadedScenes, message);
                    }
                    catch (Exception e)
                    {
@@ -2391,7 +2880,7 @@ namespace OpenSim.Region.Framework.Scenes
            }
        }
-        public void TriggerSceneObjectPartUpdated(SceneObjectPart sop)
+        public void TriggerSceneObjectPartUpdated(SceneObjectPart sop, bool full)
        {
            SceneObjectPartUpdated handler = OnSceneObjectPartUpdated;
            if (handler != null)
@@ -2400,7 +2889,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 906c1ee..6208a57 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 649d545..2543333 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();
@@ -1272,6 +1352,14 @@ namespace OpenSim.Region.Framework.Scenes
            m_log.Debug("[SCENE]: Graph close");
            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)
            {
                m_log.Debug("[SCENE]: Dispose Physics");
@@ -1281,13 +1369,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.
-            m_log.Debug("[SCENE]: Base close");
-            base.Close();
        }
        /// <summary>
@@ -1295,6 +1376,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;
@@ -1354,7 +1437,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()
        {
@@ -1411,7 +1494,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;
@@ -1473,7 +1556,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;
@@ -1672,15 +1755,19 @@ namespace OpenSim.Region.Framework.Scenes
        private void CheckAtTargets()
        {
-            List<SceneObjectGroup> objs = new List<SceneObjectGroup>();
+            List<SceneObjectGroup> objs = null;
            lock (m_groupsWithTargets)
            {
-                foreach (SceneObjectGroup grp in m_groupsWithTargets.Values)
+                if (m_groupsWithTargets.Count != 0)
-                    objs.Add(grp);
+                    objs = new List<SceneObjectGroup>(m_groupsWithTargets.Values);
            }
-            foreach (SceneObjectGroup entry in objs)
+            if (objs != null)
-                entry.checkAtTargets();
+            {
+                foreach (SceneObjectGroup entry in objs)
+                    entry.checkAtTargets();
+            }
        }
        /// <summary>
@@ -2193,10 +2280,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 (m_sceneGraph.AddRestoredSceneObject(sceneObject, attachToBackup, alreadyPersisted, sendClientUpdates))
-            if (result)
+            {
                sceneObject.IsDeleted = false;
-            return result;
+                EventManager.TriggerObjectAddedToScene(sceneObject);
+                return true;
+            }
+            return false;
        }
        
        /// <summary>
@@ -2837,77 +2928,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
+            // We lock here on AgentCircuitData to prevent a race condition between the thread adding a new connection
-                = (aCircuit.teleportFlags & (uint)Constants.TeleportFlags.ViaHGLogin) != 0
+            // and a simultaneous one that removes it (as can happen if the client is closed at a particular point
-                    || (aCircuit.teleportFlags & (uint)Constants.TeleportFlags.ViaLogin) != 0;
+            // whilst connecting).
+            //
-            CheckHeartbeat();
+            // 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
-            ScenePresence sp = GetScenePresence(client.AgentId);
+            // response in some module listening to AddNewClient()) from holding up unrelated agent calls.
+            //
-            // XXX: Not sure how good it is to add a new client if a scene presence already exists.  Possibly this
+            // In practice, the lock (this) in LLUDPServer.AddNewClient() currently lock across all
-            // could occur if a viewer crashes and relogs before the old client is kicked out.  But this could cause
+            // AddNewClient() operations (though not other ops).
-            // other problems, and possible the code calling AddNewClient() should ensure that no client is already
+            // In the future this can be relieved once locking per agent (not necessarily on AgentCircuitData) is improved.
-            // connected.
+            lock (aCircuit)
-            if (sp == null)
+            {
-            {
+                vialogin
-                m_log.DebugFormat(
+                    = (aCircuit.teleportFlags & (uint)Constants.TeleportFlags.ViaHGLogin) != 0
-                    "[SCENE]: Adding new child scene presence {0} {1} to scene {2} at pos {3}",
+                        || (aCircuit.teleportFlags & (uint)Constants.TeleportFlags.ViaLogin) != 0;
-                    client.Name, client.AgentId, RegionInfo.RegionName, client.StartPos);
+    
+                CheckHeartbeat();
-                m_clientManager.Add(client);
+    
-                SubscribeToClientEvents(client);
+                sp = GetScenePresence(client.AgentId);
-                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.
+                // XXX: Not sure how good it is to add a new client if a scene presence already exists.  Possibly this
-                // For this agent we will have to rez the attachments.
+                // could occur if a viewer crashes and relogs before the old client is kicked out.  But this could cause
-                // All other AddNewClient calls find aCircuit.child to be true.
+                // other problems, and possible the code calling AddNewClient() should ensure that no client is already
-                if (aCircuit.child == false)
+                // connected.
+                if (sp == null)
                {
-                    // We have to set SP to be a root agent here so that SP.MakeRootAgent() will later not try to
+                    m_log.DebugFormat(
-                    // start the scripts again (since this is done in RezAttachments()).
+                        "[SCENE]: Adding new child scene presence {0} {1} to scene {2} at pos {3}",
-                    // XXX: This is convoluted.
+                        client.Name, client.AgentId, RegionInfo.RegionName, client.StartPos);
-                    sp.IsChildAgent = false;
+    
+                    m_clientManager.Add(client);
-                    if (AttachmentsModule != null)
+                    SubscribeToClientEvents(client);
-                        Util.FireAndForget(delegate(object o) { AttachmentsModule.RezAttachments(sp); });
+    
+                    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
-            else
+                {
-            {
+                    m_log.WarnFormat(
-                m_log.WarnFormat(
+                        "[SCENE]: Already found {0} scene presence for {1} in {2} when asked to add new scene presence",
-                    "[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);
-                    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
+                // Cache the user's name
-            // client is for a root or child agent.
+                CacheUserName(sp, aCircuit);
-            client.SceneAgent = sp;
+    
+                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;
        }
@@ -3447,110 +3550,132 @@ namespace OpenSim.Region.Framework.Scenes
        {
 //            CheckHeartbeat();
            bool isChildAgent = false;
-            ScenePresence avatar = GetScenePresence(agentID);
+            AgentCircuitData acd;
-            if (avatar == null)
+            lock (m_removeClientLock)
            {
-                m_log.WarnFormat(
+                acd = m_authenticateHandler.GetAgentCircuitData(agentID);
-                    "[SCENE]: Called RemoveClient() with agent ID {0} but no such presence is in the scene.", agentID);
-                return;
-            }
-            try
-            {
-                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 (acd == null)
-                if (closeChildAgents && isChildAgent)
                {
-                    // Tell a single agent to disconnect from the region.
+                    m_log.ErrorFormat("[SCENE]: No agent circuit found for {0}, aborting Scene.RemoveClient", agentID);
-                    IEventQueue eq = RequestModuleInterface<IEventQueue>();
+                    return;
-                    if (eq != null)
-                    {
-                        eq.DisableSimulator(RegionInfo.RegionHandle, avatar.UUID);
-                    }
-                    else
-                    {
-                        avatar.ControllingClient.SendShutdownConnectionNotice();
-                    }
                }
+                else
-                // Only applies to root agents.
-                if (avatar.ParentID != 0)
                {
-                    avatar.StandUp();
+                    // We remove the acd up here to avoid later race conditions if two RemoveClient() calls occurred
+                    // simultaneously.
+                    // We also need to remove by agent ID since NPCs will have no circuit code.
+                    m_authenticateHandler.RemoveCircuit(agentID);
                }
+            }
-                m_sceneGraph.removeUserCount(!isChildAgent);
+            lock (acd)
+            {
-                // TODO: We shouldn't use closeChildAgents here - it's being used by the NPC module to stop
+                ScenePresence avatar = GetScenePresence(agentID);
-                // unnecessary operations.  This should go away once NPCs have no accompanying IClientAPI
+    
-                if (closeChildAgents && CapsModule != null)
+                if (avatar == 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)
                {
-                    List<ulong> regions = avatar.KnownRegionHandles;
+                    m_log.WarnFormat(
-                    regions.Remove(RegionInfo.RegionHandle);
+                        "[SCENE]: Called RemoveClient() with agent ID {0} but no such presence is in the scene.", agentID);
-                    m_sceneGridService.SendCloseChildAgentConnections(agentID, regions);
+    
+                    return;
                }
+    
-                m_eventManager.TriggerClientClosed(agentID, this);
+                try
-                m_eventManager.TriggerOnRemovePresence(agentID);
-                if (!isChildAgent)
                {
-                    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)
                    {
-                        AttachmentsModule.DeRezAttachments(avatar);
+                        // 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();
+                        }
                    }
+    
-                    ForEachClient(
+                    // Only applies to root agents.
-                        delegate(IClientAPI client)
+                    if (avatar.ParentID != 0)
+                    {
+                        avatar.StandUp();
+                    }
+    
+                    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
+                            AttachmentsModule.DeRezAttachments(avatar);
-                            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);
-                m_authenticateHandler.RemoveCircuit(avatar.ControllingClient.CircuitCode);
+                        ForEachClient(
-                m_log.Debug("[Scene] The avatar has left the building");
+                            delegate(IClientAPI client)
-            }
+                            {
-            catch (Exception e)
+                                //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 }); }
-                m_log.Error(
+                                catch (NullReferenceException) { }
-                    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();
+                    // 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);
+                    }
                }
            }
@@ -3609,11 +3734,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>
@@ -3624,10 +3747,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
@@ -3726,83 +3859,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;
            }
+            lock (agent)
-            //On login test land permisions
-            if (vialogin)
            {
-                IUserAccountCacheModule cache = RequestModuleInterface<IUserAccountCacheModule>();
+                //On login test land permisions
-                if (cache != null)
+                if (vialogin)
-                    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());
+                    IUserAccountCacheModule cache = RequestModuleInterface<IUserAccountCacheModule>();
-                    return false;
+                    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 (sp == null) // We don't have an [child] agent here already
-            {
-                if (requirePresenceLookup)
                {
-                    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
+                    m_log.InfoFormat(
-                {
+                        "[SCENE]: Region {0} authenticated and authorized incoming {1} agent {2} {3} {4} (circuit code {5})",
-                    // Always check estate if this is a login. Always
+                        RegionInfo.RegionName, (agent.child ? "child" : "root"), agent.firstname, agent.lastname,
-                    // check if banned regions are to be blacked out.
+                        agent.AgentID, agent.circuitcode);
-                    if (vialogin || (!m_seeIntoBannedRegion))
+                    if (CapsModule != null)
                    {
-                        if (!AuthorizeUser(agent, out reason))
+                        CapsModule.SetAgentCapsSeeds(agent);
-                            return false;
+                        CapsModule.CreateCaps(agent.AgentID);
                    }
                }
-                catch (Exception e)
+                else
                {
-                    m_log.ErrorFormat(
+                    // Let the SP know how we got here. This has a lot of interesting
-                        "[SCENE]: Exception authorizing user {0}{1}", e.Message, e.StackTrace);
+                    // uses down the line.
-                    return false;
+                    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)
+                    if (sp.IsChildAgent)
-                {
+                    {
-                    CapsModule.SetAgentCapsSeeds(agent);
+                        m_log.DebugFormat(
-                    CapsModule.CreateCaps(agent.AgentID);
+                            "[SCENE]: Adjusting known seeds for existing agent {0} in {1}",
-                }
+                            agent.AgentID, RegionInfo.RegionName);
-            } 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)
+                        sp.AdjustKnownSeeds();
-                {
-                    m_log.DebugFormat(
-                        "[SCENE]: Adjusting known seeds for existing agent {0} in {1}",
-                        agent.AgentID, RegionInfo.RegionName);
-                    sp.AdjustKnownSeeds();
+                        if (CapsModule != null)
-                    
+                            CapsModule.SetAgentCapsSeeds(agent);
-                    if (CapsModule != null)
+                    }
-                        CapsModule.SetAgentCapsSeeds(agent);
                }
            }
@@ -4233,8 +4369,9 @@ namespace OpenSim.Region.Framework.Scenes
                return false;
            }
-            // We have to wait until the viewer contacts this region after receiving EAC.
+            // We have to wait until the viewer contacts this region
-            // That calls AddNewClient, which finally creates the ScenePresence
+            // 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)
@@ -4329,15 +4466,18 @@ namespace OpenSim.Region.Framework.Scenes
        /// Tell a single agent to disconnect from the region.
        /// </summary>
        /// <param name="agentID"></param>
-        /// <param name="childOnly"></param>
+        /// <param name="force">
-        public bool IncomingCloseAgent(UUID agentID, bool childOnly)
+        /// 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;
            }
@@ -4543,6 +4683,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);
@@ -4773,13 +4923,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>
@@ -4791,6 +4952,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>
@@ -4822,6 +4995,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>
@@ -4915,14 +5100,15 @@ namespace OpenSim.Region.Framework.Scenes
                client.SendRegionHandle(regionID, handle);
        }
-        public bool NeedSceneCacheClear(UUID agentID)
+// 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)
+//            IInventoryTransferModule inv = RequestModuleInterface<IInventoryTransferModule>();
-                return true;
+//            if (inv == null)
+//                return true;
-            return inv.NeedSceneCacheClear(agentID, this);
+//
-        }
+//            return inv.NeedSceneCacheClear(agentID, this);
+//        }
        public void CleanTempObjects()
        {
@@ -5876,6 +6062,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))
@@ -5886,6 +6075,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))
@@ -5903,6 +6095,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 = Math.Max(m_parentScene.m_minNonphys, Math.Min(m_parentScene.m_maxNonphys, scale.X));
-                        scale.X = m_parentScene.m_maxNonphys;
+                    scale.Y = Math.Max(m_parentScene.m_minNonphys, Math.Min(m_parentScene.m_maxNonphys, scale.Y));
-                    if (scale.Y > m_parentScene.m_maxNonphys)
+                    scale.Z = Math.Max(m_parentScene.m_minNonphys, Math.Min(m_parentScene.m_maxNonphys, scale.Z));
-                        scale.Y = m_parentScene.m_maxNonphys;
-                    if (scale.Z > m_parentScene.m_maxNonphys)
-                        scale.Z = m_parentScene.m_maxNonphys;
                    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);
+//            m_log.DebugFormat(
-            scale.Y = Math.Min(scale.Y, Scene.m_maxNonphys);
+//                "[SCENE OBJECT GROUP]: Group resizing {0} {1} from {2} to {3}", Name, LocalId, RootPart.Scale, scale);
-            scale.Z = Math.Min(scale.Z, Scene.m_maxNonphys);
            PhysicsActor pa = m_rootPart.PhysActor;
-            if (pa != null && pa.IsPhysical)
+            if (Scene != null)
            {
-                scale.X = Math.Min(scale.X, Scene.m_maxPhys);
+                scale.X = Math.Max(Scene.m_minNonphys, Math.Min(Scene.m_maxNonphys, scale.X));
-                scale.Y = Math.Min(scale.Y, Scene.m_maxPhys);
+                scale.Y = Math.Max(Scene.m_minNonphys, Math.Min(Scene.m_maxNonphys, scale.Y));
-                scale.Z = Math.Min(scale.Z, Scene.m_maxPhys);
+                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;
+            SceneObjectPart[] parts = m_parts.GetArray();
-            if (x > 1.0f || y > 1.0f || z > 1.0f)
+            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 165dd85..2191cfa 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);
                    }
                }
            }
@@ -2864,6 +2864,35 @@ namespace OpenSim.Region.Framework.Scenes
                SendLandCollisionEvent(scriptEvents.land_collision_end, ParentGroup.Scene.EventManager.TriggerScriptLandCollidingEnd);
        }
+        // The Collision sounds code calls this
+        public void SendCollisionSound(UUID soundID, double volume, Vector3 position)
+        {
+            if (soundID == UUID.Zero)
+                return;
+            ISoundModule soundModule = ParentGroup.Scene.RequestModuleInterface<ISoundModule>();
+            if (soundModule == null)
+                return;
+            if (volume > 1)
+                volume = 1;
+            if (volume < 0)
+                volume = 0;
+            int now = Util.EnvironmentTickCount();
+            if(Util.EnvironmentTickCountSubtract(now,LastColSoundSentTime) <200)
+                return;
+            LastColSoundSentTime = now;
+            UUID ownerID = OwnerID;
+            UUID objectID = ParentGroup.RootPart.UUID;
+            UUID parentID = ParentGroup.UUID;
+            ulong regionHandle = ParentGroup.Scene.RegionInfo.RegionHandle;
+            soundModule.TriggerSound(soundID, ownerID, objectID, parentID, volume, position, regionHandle, 0 );
+        }
        public void PhysicsOutOfBounds(Vector3 pos)
        {
            m_log.Error("[PHYSICS]: Physical Object went out of bounds.");
@@ -2895,38 +2924,6 @@ namespace OpenSim.Region.Framework.Scenes
            ScheduleTerseUpdate();
        }
-        public void PreloadSound(string sound)
-        {
-            // UUID ownerID = OwnerID;
-            UUID objectID = ParentGroup.RootPart.UUID;
-            UUID soundID = UUID.Zero;
-            if (!UUID.TryParse(sound, out soundID))
-            {
-                //Trys to fetch sound id from prim's inventory.
-                //Prim's inventory doesn't support non script items yet
-                
-                TaskInventory.LockItemsForRead(true);
-                foreach (KeyValuePair<UUID, TaskInventoryItem> item in TaskInventory)
-                {
-                    if (item.Value.Name == sound)
-                    {
-                        soundID = item.Value.ItemID;
-                        break;
-                    }
-                }
-                TaskInventory.LockItemsForRead(false);
-            }
-            ParentGroup.Scene.ForEachRootScenePresence(delegate(ScenePresence sp)
-            {
-                if (!(Util.GetDistanceTo(sp.AbsolutePosition, AbsolutePosition) >= 100))
-                    sp.ControllingClient.SendPreLoadSound(objectID, objectID, soundID);
-            });
-        }
        public void RemFlag(PrimFlags flag)
        {
            // PrimFlags prevflag = Flags;
@@ -2979,17 +2976,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.X = Math.Max(ParentGroup.Scene.m_minNonphys, Math.Min(ParentGroup.Scene.m_maxNonphys, scale.X));
-                scale.Y = Math.Min(scale.Y, ParentGroup.Scene.m_maxPhys);
+                scale.Y = Math.Max(ParentGroup.Scene.m_minNonphys, Math.Min(ParentGroup.Scene.m_maxNonphys, scale.Y));
-                scale.Z = Math.Min(scale.Z, ParentGroup.Scene.m_maxPhys);
+                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 +3086,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 +3120,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)
@@ -3295,126 +3295,6 @@ namespace OpenSim.Region.Framework.Scenes
        }
        /// <summary>
-        /// Trigger or play an attached sound in this part's inventory.
-        /// </summary>
-        /// <param name="sound"></param>
-        /// <param name="volume"></param>
-        /// <param name="triggered"></param>
-        /// <param name="flags"></param>
-        public void SendSound(string sound, double volume, bool triggered, byte flags, float radius, bool useMaster, bool isMaster)
-        {
-            if (volume > 1)
-                volume = 1;
-            if (volume < 0)
-                volume = 0;
-            UUID ownerID = OwnerID;
-            UUID objectID = ParentGroup.RootPart.UUID;
-            UUID parentID = ParentGroup.UUID;
-            UUID soundID = UUID.Zero;
-            Vector3 position = AbsolutePosition; // region local
-            ulong regionHandle = ParentGroup.Scene.RegionInfo.RegionHandle;
-            if (!UUID.TryParse(sound, out soundID))
-            {
-                // search sound file from inventory
-                TaskInventory.LockItemsForRead(true);
-                foreach (KeyValuePair<UUID, TaskInventoryItem> item in TaskInventory)
-                {
-                    if (item.Value.Name == sound && item.Value.Type == (int)AssetType.Sound)
-                    {
-                        soundID = item.Value.ItemID;
-                        break;
-                    }
-                }
-                TaskInventory.LockItemsForRead(false);
-            }
-            if (soundID == UUID.Zero)
-                return;
-            ISoundModule soundModule = ParentGroup.Scene.RequestModuleInterface<ISoundModule>();
-            if (soundModule != null)
-            {
-                if (useMaster)
-                {
-                    if (isMaster)
-                    {
-                        if (triggered)
-                            soundModule.TriggerSound(soundID, ownerID, objectID, parentID, volume, position, regionHandle, radius);
-                        else
-                            soundModule.PlayAttachedSound(soundID, ownerID, objectID, volume, position, flags, radius);
-                        ParentGroup.PlaySoundMasterPrim = this;
-                        ownerID = OwnerID;
-                        objectID = ParentGroup.RootPart.UUID;
-                        parentID = ParentGroup.UUID;
-                        position = AbsolutePosition; // region local
-                        regionHandle = ParentGroup.Scene.RegionInfo.RegionHandle;
-                        if (triggered)
-                            soundModule.TriggerSound(soundID, ownerID, objectID, parentID, volume, position, regionHandle, radius);
-                        else
-                            soundModule.PlayAttachedSound(soundID, ownerID, objectID, volume, position, flags, radius);
-                        foreach (SceneObjectPart prim in ParentGroup.PlaySoundSlavePrims)
-                        {
-                            ownerID = prim.OwnerID;
-                            objectID = prim.ParentGroup.RootPart.UUID;
-                            parentID = prim.ParentGroup.UUID;
-                            position = prim.AbsolutePosition; // region local
-                            regionHandle = prim.ParentGroup.Scene.RegionInfo.RegionHandle;
-                            if (triggered)
-                                soundModule.TriggerSound(soundID, ownerID, objectID, parentID, volume, position, regionHandle, radius);
-                            else
-                                soundModule.PlayAttachedSound(soundID, ownerID, objectID, volume, position, flags, radius);
-                        }
-                        ParentGroup.PlaySoundSlavePrims.Clear();
-                        ParentGroup.PlaySoundMasterPrim = null;
-                    }
-                    else
-                    {
-                        ParentGroup.PlaySoundSlavePrims.Add(this);
-                    }
-                }
-                else
-                {
-                    if (triggered)
-                        soundModule.TriggerSound(soundID, ownerID, objectID, parentID, volume, position, regionHandle, radius);
-                    else
-                        soundModule.PlayAttachedSound(soundID, ownerID, objectID, volume, position, flags, radius);
-                }
-            }
-        }
-        public void SendCollisionSound(UUID soundID, double volume, Vector3 position)
-        {
-            if (soundID == UUID.Zero)
-                return;
-            ISoundModule soundModule = ParentGroup.Scene.RequestModuleInterface<ISoundModule>();
-            if (soundModule == null)
-                return;
-            if (volume > 1)
-                volume = 1;
-            if (volume < 0)
-                volume = 0;
-            int now = Util.EnvironmentTickCount();
-            if(Util.EnvironmentTickCountSubtract(now,LastColSoundSentTime) <200)
-                return;
-            LastColSoundSentTime = now;
-            UUID ownerID = OwnerID;
-            UUID objectID = ParentGroup.RootPart.UUID;
-            UUID parentID = ParentGroup.UUID;
-            ulong regionHandle = ParentGroup.Scene.RegionInfo.RegionHandle;
-            soundModule.TriggerSound(soundID, ownerID, objectID, parentID, volume, position, regionHandle, 0 );
-        }
-        /// <summary>
        /// Send a terse update to all clients
        /// </summary>
        public void SendTerseUpdateToAllClients()
@@ -3575,23 +3455,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.R = clippedColor.X;
-                texcolor.G = Util.Clip((float)color.Y, 0.0f, 1.0f);
+                texcolor.G = clippedColor.Y;
-                texcolor.B = Util.Clip((float)color.Z, 0.0f, 1.0f);
+                texcolor.B = clippedColor.Z;
+                if (alpha.HasValue)
+                {
+                    texcolor.A = clippedAlpha;
+                }
                tex.FaceTextures[face].RGBA = texcolor;
                UpdateTextureEntry(tex.GetBytes());
                return;
@@ -3603,15 +3492,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.R = clippedColor.X;
-                        texcolor.G = Util.Clip((float)color.Y, 0.0f, 1.0f);
+                        texcolor.G = clippedColor.Y;
-                        texcolor.B = Util.Clip((float)color.Z, 0.0f, 1.0f);
+                        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.R = clippedColor.X;
-                    texcolor.G = Util.Clip((float)color.Y, 0.0f, 1.0f);
+                    texcolor.G = clippedColor.Y;
-                    texcolor.B = Util.Clip((float)color.Z, 0.0f, 1.0f);
+                    texcolor.B = clippedColor.Z;
+                    if (alpha.HasValue)
+                    {
+                        texcolor.A = clippedAlpha;
+                    }
                    tex.DefaultTexture.RGBA = texcolor;
                }
                UpdateTextureEntry(tex.GetBytes());
@@ -4899,6 +4796,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..3a9a146 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
@@ -235,31 +244,52 @@ namespace OpenSim.Region.Framework.Scenes
            if (m_part == null || m_part.ParentGroup == null || m_part.ParentGroup.Scene == null)
                return;
-            IScriptModule[] engines = m_part.ParentGroup.Scene.RequestModuleInterfaces<IScriptModule>();
-            if (engines == null) // No engine at all
-                return;
            Items.LockItemsForRead(true);
            foreach (TaskInventoryItem item in Items.Values)
            {
                if (item.InvType == (int)InventoryType.LSL)
                {
-                    foreach (IScriptModule e in engines)
+                    bool running;
-                    {
+                    if (TryGetScriptInstanceRunning(m_part.ParentGroup.Scene, item, out running))
-                        bool running;
+                        item.ScriptRunning = running;
-                        if (e.HasScript(item.ItemID, out running))
-                        {
-                            item.ScriptRunning = running;
-                            break;
-                        }
-                    }
                }
            }
            Items.LockItemsForRead(false);
        }
+        public bool TryGetScriptInstanceRunning(UUID itemId, out bool running)
+        {
+            running = false;
+            TaskInventoryItem item = GetInventoryItem(itemId);
+            if (item == null)
+                return false;
+            return TryGetScriptInstanceRunning(m_part.ParentGroup.Scene, item, out running);
+        }
+        public static bool TryGetScriptInstanceRunning(Scene scene, TaskInventoryItem item, out bool running)
+        {
+            running = false;
+            if (item.InvType != (int)InventoryType.LSL)
+                return false;
+            IScriptModule[] engines = scene.RequestModuleInterfaces<IScriptModule>();
+            if (engines == null) // No engine at all
+                return false;
+            foreach (IScriptModule e in engines)
+            {
+                if (e.HasScript(item.ItemID, out running))
+                    return true;
+            }
+            return false;
+        }
        public int CreateScriptInstances(int startParam, bool postOnRez, string engine, int stateSource)
        {
            int scriptsValidForStarting = 0;
diff --git a/OpenSim/Region/Framework/Scenes/ScenePresence.cs b/OpenSim/Region/Framework/Scenes/ScenePresence.cs
index 2b9665c..25a53b4 100644
--- a/OpenSim/Region/Framework/Scenes/ScenePresence.cs
+++ b/OpenSim/Region/Framework/Scenes/ScenePresence.cs
@@ -1,4 +1,4 @@
-/*
+/*
 * Copyright (c) Contributors, http://opensimulator.org/
 * See CONTRIBUTORS.TXT for a full list of copyright holders.
 *
@@ -69,14 +69,15 @@ 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
    {
 //        ~ScenePresence()
 //        {
-//            m_log.Debug("[SCENE PRESENCE] Destructor called");
+//            m_log.DebugFormat("[SCENE PRESENCE]: Destructor called on {0}", Name);
 //        }
        private void TriggerScenePresenceUpdated()
        {
            if (m_scene != null)
@@ -188,7 +189,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();
@@ -546,7 +547,7 @@ namespace OpenSim.Region.Framework.Scenes
                {
                    try
                    {
-                        PhysicsActor.Velocity = value;
+                        PhysicsActor.TargetVelocity = value;
                    }
                    catch (Exception e)
                    {
@@ -711,7 +712,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;
@@ -975,7 +976,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)
@@ -1531,17 +1534,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)
                {
@@ -2623,17 +2631,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)
@@ -2837,7 +2845,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()
        {
@@ -3274,6 +3282,7 @@ namespace OpenSim.Region.Framework.Scenes
            }
            catch { }
            cAgent.DefaultAnim = Animator.Animations.DefaultAnimation;
+            cAgent.AnimState = Animator.Animations.ImplicitDefaultAnimation;
            if (Scene.AttachmentsModule != null)
                Scene.AttachmentsModule.CopyAttachments(this, cAgent);
@@ -3350,6 +3359,8 @@ namespace OpenSim.Region.Framework.Scenes
                Animator.Animations.FromArray(cAgent.Anims);
            if (cAgent.DefaultAnim != null)
                Animator.Animations.SetDefaultAnimation(cAgent.DefaultAnim.AnimID, cAgent.DefaultAnim.SequenceNum, UUID.Zero);
+            if (cAgent.AnimState != null)
+                Animator.Animations.SetImplicitDefaultAnimation(cAgent.AnimState.AnimID, cAgent.AnimState.SequenceNum, UUID.Zero);
            if (Scene.AttachmentsModule != null)
                Scene.AttachmentsModule.CopyAttachments(cAgent, this);
@@ -3632,13 +3643,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)
+                    foreach (SceneObjectGroup so in m_attachments)
-                        attachments.Add(so);
+                    {
+                        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>
+        protected IAssetService m_assetService;
-        /// Signal whether we are currently waiting for the asset service to deliver an asset.
-        /// </summary>
+//        /// <summary>
-        private bool m_waitingForObjectAsset;
+//        /// 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>
+//        /// <summary>
-        /// The callback made when we request the asset for an object from the asset service.
+//        /// The callback made when we request the asset for an object from the asset service.
-        /// </summary>
+//        /// </summary>
-        private void AssetReceived(string id, Object sender, AssetBase asset)
+//        private void AssetReceived(string id, Object sender, AssetBase asset)
-        {
+//        {
-            lock (this)
+//            lock (this)
-            {
+//            {
-                m_requestedObjectAsset = asset;
+//                m_requestedObjectAsset = asset;
-                m_waitingForObjectAsset = false;
+//                m_waitingForObjectAsset = false;
-                Monitor.Pulse(this);
+//                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;
+            return m_assetService.Get(uuid.ToString());
-            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;
+            // 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;
+        }
+    }
 }