This changeset is the step 1 of 2 in refactoring

OpenSim.Region.Environment into a "framework" part and a modules only
part. This first changeset refactors OpenSim.Region.Environment.Scenes,
OpenSim.Region.Environment.Interfaces, and OpenSim.Region.Interfaces
into OpenSim.Region.Framework.{Interfaces,Scenes} leaving only region
modules in OpenSim.Region.Environment.

The next step will be to move region modules up from
OpenSim.Region.Environment.Modules to OpenSim.Region.CoreModules and
then sort out which modules are really core modules and which should
move out to forge.

I've been very careful to NOT BREAK anything. i hope i've
succeeded. as this is the work of a whole week i hope i managed to
keep track with the applied patches of the last week --- could any of
you that did check in stuff have a look at whether it survived? thx!

1 files changed, 3012 insertions, 0 deletions

diff --git a/OpenSim/Region/Framework/Scenes/SceneObjectGroup.cs b/OpenSim/Region/Framework/Scenes/SceneObjectGroup.cs
new file mode 100644
index 0000000..57d9ce4
--- /dev/null
+++ b/OpenSim/Region/Framework/Scenes/SceneObjectGroup.cs
@@ -0,0 +1,3012 @@
+/*
+ * 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 OpenSim 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 System.Drawing;
+using System.IO;
+using System.Xml;
+using System.Xml.Serialization;
+using OpenMetaverse;
+using OpenMetaverse.Packets;
+using OpenSim.Framework;
+using OpenSim.Region.Framework.Interfaces;
+using OpenSim.Region.Physics.Manager;
+
+namespace OpenSim.Region.Framework.Scenes
+{
+    [Flags]
+    public enum scriptEvents
+    {
+        None = 0,
+        attach = 1,
+        collision = 16,
+        collision_end = 32,
+        collision_start = 64,
+        control = 128,
+        dataserver = 256,
+        email = 512,
+        http_response = 1024,
+        land_collision = 2048,
+        land_collision_end = 4096,
+        land_collision_start = 8192,
+        at_target = 16384,
+        listen = 32768,
+        money = 65536,
+        moving_end = 131072,
+        moving_start = 262144,
+        not_at_rot_target = 524288,
+        not_at_target = 1048576,
+        remote_data = 8388608,
+        run_time_permissions = 268435456,
+        state_entry = 1073741824,
+        state_exit = 2,
+        timer = 4,
+        touch = 8,
+        touch_end = 536870912,
+        touch_start = 2097152,
+        object_rez = 4194304
+    }
+
+    struct scriptPosTarget
+    {
+        public Vector3 targetPos;
+        public float tolerance;
+    }
+
+    public delegate void PrimCountTaintedDelegate();
+
+    /// <summary>
+    /// A scene object group is conceptually an object in the scene.  The object is constituted of SceneObjectParts
+    /// (often known as prims), one of which is considered the root part.
+    /// </summary>
+    public partial class SceneObjectGroup : EntityBase
+    {
+        // private PrimCountTaintedDelegate handlerPrimCountTainted = null;
+
+        /// <summary>
+        /// Signal whether the non-inventory attributes of any prims in the group have changed
+        /// since the group's last persistent backup
+        /// </summary>
+        private bool m_hasGroupChanged = false;
+        private long timeFirstChanged;
+        private long timeLastChanged;
+
+        public bool HasGroupChanged
+        {
+            set
+            {
+                if (value)
+                {
+                    timeLastChanged = DateTime.Now.Ticks;
+                    if (!m_hasGroupChanged)
+                        timeFirstChanged = DateTime.Now.Ticks;
+                }
+                m_hasGroupChanged = value;
+            }
+
+            get { return m_hasGroupChanged; }
+        }
+
+        private bool isTimeToPersist()
+        {
+            if (IsSelected || IsDeleted || IsAttachment)
+                return false;
+            if (!m_hasGroupChanged)
+                return false;
+            if (m_scene.ShuttingDown)
+                return true;
+            long currentTime = DateTime.Now.Ticks;
+            if (currentTime - timeLastChanged > m_scene.m_dontPersistBefore || currentTime - timeFirstChanged > m_scene.m_persistAfter)
+                return true;
+            return false;
+        }
+        
+        /// <value>
+        /// Is this scene object acting as an attachment?
+        /// 
+        /// We return false if the group has already been deleted.
+        ///  
+        /// TODO: At the moment set must be done on the part itself.  There may be a case for doing it here since I
+        /// presume either all or no parts in a linkset can be part of an attachment (in which
+        /// case the value would get proprogated down into all the descendent parts).
+        /// </value>
+        public bool IsAttachment
+        {
+            get
+            {
+                if (!IsDeleted)
+                    return m_rootPart.IsAttachment;
+                
+                return false;
+            }
+        }
+
+        public float scriptScore = 0f;
+
+        private Vector3 lastPhysGroupPos;
+        private Quaternion lastPhysGroupRot;
+
+        private bool m_isBackedUp = false;
+
+        /// <summary>
+        /// The constituent parts of this group
+        /// </summary>
+        protected Dictionary<UUID, SceneObjectPart> m_parts = new Dictionary<UUID, SceneObjectPart>();
+
+        protected ulong m_regionHandle;
+        protected SceneObjectPart m_rootPart;
+        // private Dictionary<UUID, scriptEvents> m_scriptEvents = new Dictionary<UUID, scriptEvents>();
+
+        private Dictionary<uint, scriptPosTarget> m_targets = new Dictionary<uint, scriptPosTarget>();
+
+        private bool m_scriptListens_atTarget = false;
+        private bool m_scriptListens_notAtTarget = false;
+
+        #region Properties
+
+        /// <summary>
+        /// The name of an object grouping is always the same as its root part
+        /// </summary>
+        public override string Name
+        {
+            get {
+                if (RootPart == null)
+                    return "";
+                return RootPart.Name;
+            }
+            set { RootPart.Name = value; }
+        }
+
+        /// <summary>
+        /// Added because the Parcel code seems to use it
+        /// but not sure a object should have this
+        /// as what does it tell us? that some avatar has selected it (but not what Avatar/user)
+        /// think really there should be a list (or whatever) in each scenepresence
+        /// saying what prim(s) that user has selected.
+        /// </summary>
+        protected bool m_isSelected = false;
+
+        /// <summary>
+        /// Number of prims in this group
+        /// </summary>
+        public int PrimCount
+        {
+            get { return m_parts.Count; }
+        }
+
+        public Quaternion GroupRotation
+        {
+            get { return m_rootPart.RotationOffset; }
+        }
+
+        public UUID GroupID
+        {
+            get { return m_rootPart.GroupID; }
+            set { m_rootPart.GroupID = value; }
+        }
+
+        public Dictionary<UUID, SceneObjectPart> Children
+        {
+            get { return m_parts; }
+            set { m_parts = value; }
+        }
+
+        /// <value>
+        /// The root part of this scene object
+        /// </value>
+        public SceneObjectPart RootPart
+        {
+            get { return m_rootPart; }
+        }
+
+        public ulong RegionHandle
+        {
+            get { return m_regionHandle; }
+            set
+            {
+                m_regionHandle = value;
+                lock (m_parts)
+                {
+                    foreach (SceneObjectPart part in m_parts.Values)
+                    {
+                        part.RegionHandle = m_regionHandle;
+                    }
+                }
+            }
+        }
+
+        /// <summary>
+        /// The absolute position of this scene object in the scene
+        /// </summary>
+        public override Vector3 AbsolutePosition
+        {
+            get
+            {
+                if (m_rootPart == null)
+                {
+                    throw new NullReferenceException(
+                        string.Format("[SCENE OBJECT GROUP]: Object {0} has no root part.", m_uuid));
+                }
+
+                return m_rootPart.GroupPosition;
+            }
+            set
+            {
+                Vector3 val = value;
+                
+                if ((val.X > 257f || val.X < -1f || val.Y > 257f || val.Y < -1f) && !IsAttachment)
+                {                                       
+                    m_scene.CrossPrimGroupIntoNewRegion(val, this, true);
+                }
+
+                lock (m_parts)
+                {
+                    foreach (SceneObjectPart part in m_parts.Values)
+                    {
+                        part.GroupPosition = val;
+                    }
+                }
+
+                //if (m_rootPart.PhysActor != null)
+                //{
+                //m_rootPart.PhysActor.Position =
+                //new PhysicsVector(m_rootPart.GroupPosition.X, m_rootPart.GroupPosition.Y,
+                //m_rootPart.GroupPosition.Z);
+                //m_scene.PhysicsScene.AddPhysicsActorTaint(m_rootPart.PhysActor);
+                //}
+            }
+        }
+
+        public override uint LocalId
+        {
+            get
+            {
+                if (m_rootPart == null)
+                {
+                    m_log.Error("[SCENE OBJECT GROUP]: Unable to find the rootpart for a LocalId Request!");
+                    return 0;
+                }
+
+                return m_rootPart.LocalId;
+            }
+            set { m_rootPart.LocalId = value; }
+        }
+
+        public override UUID UUID
+        {
+            get {
+                if (m_rootPart == null)
+                {
+                    m_log.Error("Got a null rootpart while requesting UUID. Called from: ", new Exception());
+                    return UUID.Zero;
+                }
+                else return m_rootPart.UUID;
+            }
+            set { m_rootPart.UUID = value; }
+        }
+
+        public UUID OwnerID
+        {
+            get
+            {
+                if (m_rootPart == null)
+                    return UUID.Zero;
+
+                return m_rootPart.OwnerID;
+            }
+            set { m_rootPart.OwnerID = value; }
+        }
+
+        public Color Color
+        {
+            get { return m_rootPart.Color; }
+            set { m_rootPart.Color = value; }
+        }
+
+        public string Text
+        {
+            get {
+                string returnstr = m_rootPart.Text;
+                if (returnstr.Length  > 255)
+                {
+                    returnstr = returnstr.Substring(0, 255);
+                }
+                return returnstr;
+            }
+            set { m_rootPart.Text = value; }
+        }
+
+        protected virtual bool InSceneBackup
+        {
+            get { return true; }
+        }
+
+        public bool IsSelected
+        {
+            get { return m_isSelected; }
+            set
+            {
+                m_isSelected = value;
+                // Tell physics engine that group is selected
+                if (m_rootPart != null && m_rootPart.PhysActor != null)
+                {
+                    m_rootPart.PhysActor.Selected = value;
+                    // Pass it on to the children.
+                    foreach (SceneObjectPart child in Children.Values)
+                    {
+                        if (child.PhysActor != null)
+                        {
+                            child.PhysActor.Selected = value;
+                        }
+                    }
+                }
+            }
+        }
+
+        // The UUID for the Region this Object is in.
+        public UUID RegionUUID
+        {
+            get
+            {
+                if (m_scene != null)
+                {
+                    return m_scene.RegionInfo.RegionID;
+                }
+                return UUID.Zero;
+            }
+        }
+
+        #endregion
+
+        #region Constructors
+
+        /// <summary>
+        /// Constructor
+        /// </summary>
+        public SceneObjectGroup()
+        {
+        }
+
+        /// <summary>
+        /// This constructor creates a SceneObjectGroup using a pre-existing SceneObjectPart.
+        /// The original SceneObjectPart will be used rather than a copy, preserving
+        /// its existing localID and UUID.
+        /// </summary>
+        public SceneObjectGroup(SceneObjectPart part)
+        {
+            SetRootPart(part);
+        }
+
+        public SceneObjectGroup(string xmlData, bool isOriginalXmlFormat)
+            : this(UUID.Zero, xmlData, isOriginalXmlFormat)
+        {
+        }
+
+        /// <summary>
+        /// Create an object using serialized data in OpenSim's original xml format.
+        /// </summary>
+        /// <param name="fromUserInventoryItemID">
+        /// If applicable, the user inventory item id from which this object was rezzed.  If not applicable then this
+        /// should be UUID.Zero
+        /// </param>
+        /// <param name="xmlData"></param>
+        /// <param name="isOriginalXmlFormat">
+        /// This parameter only exists to separate the two different xml constructors.  In the future, versions should
+        /// be specified within the xml itself.
+        /// </param>
+        public SceneObjectGroup(UUID fromUserInventoryItemID, string xmlData, bool isOriginalXmlFormat)
+        {
+            if (!isOriginalXmlFormat)
+                throw new Exception("This constructor must specify the xml is in OpenSim's original format");
+
+            //m_log.DebugFormat("[SOG]: Starting deserialization of SOG");
+            int time = System.Environment.TickCount;
+
+            // libomv.types changes UUID to Guid
+            xmlData = xmlData.Replace("<UUID>", "<Guid>");
+            xmlData = xmlData.Replace("</UUID>", "</Guid>");
+
+            // Handle Nested <UUID><UUID> property
+            xmlData = xmlData.Replace("<Guid><Guid>", "<UUID><Guid>");
+            xmlData = xmlData.Replace("</Guid></Guid>", "</Guid></UUID>");
+            StringReader sr = new StringReader(xmlData);
+            XmlTextReader reader = new XmlTextReader(sr);
+
+            try
+            {
+                reader.Read();
+                reader.ReadStartElement("SceneObjectGroup");
+                reader.ReadStartElement("RootPart");
+                SetRootPart(SceneObjectPart.FromXml(fromUserInventoryItemID, reader));
+
+                reader.ReadEndElement();
+
+                while (reader.Read())
+                {
+                    switch (reader.NodeType)
+                    {
+                        case XmlNodeType.Element:
+                            if (reader.Name == "Part")
+                            {
+                                reader.Read();
+                                SceneObjectPart part = SceneObjectPart.FromXml(reader);
+                            
+                                // We reset the link number in order to make sure that the persisted linkset order is 
+                                int linkNum = part.LinkNum;
+                                AddPart(part);
+                                part.LinkNum = linkNum;
+
+                                part.TrimPermissions();
+                                part.StoreUndoState();
+                            }
+                            break;
+                        
+                        case XmlNodeType.EndElement:
+                            break;
+                    }
+                }
+            }
+            catch (XmlException e)
+            {
+                m_log.ErrorFormat("[SCENE]: Deserialization of xml failed with {0}.  xml was {1}", e, xmlData);
+            }
+
+            reader.Close();
+            sr.Close();
+            m_log.DebugFormat("[SOG]: Finished deserialization of SOG {0}, {1}ms", Name, System.Environment.TickCount - time);
+        }
+
+        /// <summary>
+        /// Create an object using serialized data in OpenSim's xml2 format.
+        /// </summary>
+        public SceneObjectGroup(string xmlData)
+        {
+            SetFromXml(xmlData);
+        }
+
+        protected void SetFromXml(string xmlData)
+        {
+            //m_log.DebugFormat("[SOG]: Starting deserialization of SOG");
+            //int time = System.Environment.TickCount;
+
+            // libomv.types changes UUID to Guid
+            xmlData = xmlData.Replace("<UUID>", "<Guid>");
+            xmlData = xmlData.Replace("</UUID>", "</Guid>");
+
+            // Handle Nested <UUID><UUID> property
+            xmlData = xmlData.Replace("<Guid><Guid>", "<UUID><Guid>");
+            xmlData = xmlData.Replace("</Guid></Guid>", "</Guid></UUID>");
+
+            StringReader sr = new StringReader(xmlData);
+            XmlTextReader reader = new XmlTextReader(sr);
+            reader.Read();
+
+            reader.ReadStartElement("SceneObjectGroup");
+            SetRootPart(CreatePartFromXml(reader));
+
+            reader.Read();
+            bool more = true;
+
+            while (more)
+            {
+                switch (reader.NodeType)
+                {
+                    case XmlNodeType.Element:
+                        if (reader.Name == "SceneObjectPart")
+                        {
+                            SceneObjectPart part = CreatePartFromXml(reader);
+                            AddPart(part);
+                            part.StoreUndoState();
+                        }
+                        else
+                        {
+                            Console.WriteLine("found unexpected element: " + reader.Name);
+                            reader.Read();
+                        }
+                        break;
+                    case XmlNodeType.EndElement:
+                        reader.Read();
+                        break;
+                }
+                more = !reader.EOF;
+            }
+
+            reader.Close();
+            sr.Close();
+
+            //m_log.DebugFormat("[SOG]: Finished deserialization of SOG {0}, {1}ms", Name, System.Environment.TickCount - time);
+        }
+
+        protected virtual SceneObjectPart CreatePartFromXml(XmlTextReader reader)
+        {
+            SceneObjectPart part = SceneObjectPart.FromXml(reader);
+            return part;
+        }
+
+        /// <summary>
+        /// Constructor.  This object is added to the scene later via AttachToScene()
+        /// </summary>
+        public SceneObjectGroup(UUID ownerID, Vector3 pos, Quaternion rot, PrimitiveBaseShape shape)
+        {
+            Vector3 rootOffset = new Vector3(0, 0, 0);   
+            SetRootPart(new SceneObjectPart(ownerID, shape, pos, rot, rootOffset));
+        }
+
+        /// <summary>
+        /// Constructor.
+        /// </summary>
+        public SceneObjectGroup(UUID ownerID, Vector3 pos, PrimitiveBaseShape shape)
+            : this(ownerID, pos, Quaternion.Identity, shape)
+        {
+        }
+
+        public void SetFromAssetID(UUID AssetId)
+        {
+            lock (m_parts)
+            {
+                foreach (SceneObjectPart part in m_parts.Values)
+                {
+                    part.FromAssetID = AssetId;
+                }
+            }
+        }
+
+        public UUID GetFromAssetID()
+        {
+            if (m_rootPart != null)
+            {
+                return m_rootPart.FromAssetID;
+            }
+            return UUID.Zero;
+        }
+
+        /// <summary>
+        /// Hooks this object up to the backup event so that it is persisted to the database when the update thread executes.
+        /// </summary>
+        public void AttachToBackup()
+        {
+            if (InSceneBackup)
+            {
+                //m_log.DebugFormat(
+                //    "[SCENE OBJECT GROUP]: Attaching object {0} {1} to scene presistence sweep", Name, UUID);
+
+                if (!m_isBackedUp)
+                    m_scene.EventManager.OnBackup += ProcessBackup;
+                
+                m_isBackedUp = true;
+            }
+        }
+        
+        /// <summary>
+        /// Attach this object to a scene.  It will also now appear to agents.
+        /// </summary>
+        /// <param name="scene"></param>
+        public void AttachToScene(Scene scene)
+        {
+            m_scene = scene;                        
+            RegionHandle = m_scene.RegionInfo.RegionHandle;
+
+            if (m_rootPart.Shape.PCode != 9 || m_rootPart.Shape.State == 0)
+                m_rootPart.ParentID = 0;
+            if (m_rootPart.LocalId==0)
+                m_rootPart.LocalId = m_scene.AllocateLocalId();
+
+            // No need to lock here since the object isn't yet in a scene
+            foreach (SceneObjectPart part in m_parts.Values)
+            {
+                if (Object.ReferenceEquals(part, m_rootPart))
+                    continue;
+                if (part.LocalId==0) 
+                    part.LocalId = m_scene.AllocateLocalId();
+                part.ParentID = m_rootPart.LocalId;
+                //m_log.DebugFormat("[SCENE]: Given local id {0} to part {1}, linknum {2}, parent {3} {4}", part.LocalId, part.UUID, part.LinkNum, part.ParentID, part.ParentUUID);
+            }
+            
+            ApplyPhysics(m_scene.m_physicalPrim);            
+            
+            ScheduleGroupForFullUpdate();            
+        }
+
+        public Vector3 GroupScale()
+        {
+            Vector3 minScale = new Vector3(Constants.RegionSize,Constants.RegionSize,Constants.RegionSize);
+            Vector3 maxScale = new Vector3(0f,0f,0f);
+            Vector3 finalScale = new Vector3(0.5f, 0.5f, 0.5f);
+
+            lock (m_parts)
+            {
+                foreach (SceneObjectPart part in m_parts.Values)
+                {
+                    Vector3 partscale = part.Scale;
+                    Vector3 partoffset = part.OffsetPosition;
+
+                    minScale.X = (partscale.X + partoffset.X < minScale.X) ? partscale.X + partoffset.X : minScale.X;
+                    minScale.Y = (partscale.Y + partoffset.Y < minScale.Y) ? partscale.X + partoffset.Y : minScale.Y;
+                    minScale.Z = (partscale.Z + partoffset.Z < minScale.Z) ? partscale.X + partoffset.Z : minScale.Z;
+
+                    maxScale.X = (partscale.X + partoffset.X > maxScale.X) ? partscale.X + partoffset.X : maxScale.X;
+                    maxScale.Y = (partscale.Y + partoffset.Y > maxScale.Y) ? partscale.Y + partoffset.Y : maxScale.Y;
+                    maxScale.Z = (partscale.Z + partoffset.Z > maxScale.Z) ? partscale.Z + partoffset.Z : maxScale.Z;
+                }
+            }
+            finalScale.X = (minScale.X > maxScale.X) ? minScale.X : maxScale.X;
+            finalScale.Y = (minScale.Y > maxScale.Y) ? minScale.Y : maxScale.Y;
+            finalScale.Z = (minScale.Z > maxScale.Z) ? minScale.Z : maxScale.Z;
+            return finalScale;
+
+        }
+        public EntityIntersection TestIntersection(Ray hRay, bool frontFacesOnly, bool faceCenters)
+        {
+            // We got a request from the inner_scene to raytrace along the Ray hRay
+            // We're going to check all of the prim in this group for intersection with the ray
+            // If we get a result, we're going to find the closest result to the origin of the ray
+            // and send back the intersection information back to the innerscene.
+
+            EntityIntersection returnresult = new EntityIntersection();
+
+            lock (m_parts)
+            {
+                foreach (SceneObjectPart part in m_parts.Values)
+                {
+                    // Temporary commented to stop compiler warning
+                    //Vector3 partPosition =
+                    //    new Vector3(part.AbsolutePosition.X, part.AbsolutePosition.Y, part.AbsolutePosition.Z);
+                    Quaternion parentrotation = GroupRotation;
+
+                    // Telling the prim to raytrace.
+                    //EntityIntersection inter = part.TestIntersection(hRay, parentrotation);
+
+                    EntityIntersection inter = part.TestIntersectionOBB(hRay, parentrotation,frontFacesOnly, faceCenters);
+
+                    // This may need to be updated to the maximum draw distance possible..
+                    // We might (and probably will) be checking for prim creation from other sims
+                    // when the camera crosses the border.
+                    float idist = Constants.RegionSize;
+
+
+                    if (inter.HitTF)
+                    {
+                        // We need to find the closest prim to return to the testcaller along the ray
+                        if (inter.distance < idist)
+                        {
+                            returnresult.HitTF = true;
+                            returnresult.ipoint = inter.ipoint;
+                            returnresult.obj = part;
+                            returnresult.normal = inter.normal;
+                            returnresult.distance = inter.distance;
+                        }
+                    }
+                }
+            }
+            return returnresult;
+        }
+
+        #endregion
+
+
+        public string ToXmlString()
+        {
+            using (StringWriter sw = new StringWriter())
+            {
+                using (XmlTextWriter writer = new XmlTextWriter(sw))
+                {
+                    ToXml(writer);
+                }
+
+                return sw.ToString();
+            }
+        }
+
+        public void ToXml(XmlTextWriter writer)
+        {
+            m_log.DebugFormat("[SOG]: Starting serialization of {0}", Name);
+            int time = System.Environment.TickCount;
+
+            writer.WriteStartElement(String.Empty, "SceneObjectGroup", String.Empty);
+            writer.WriteStartElement(String.Empty, "RootPart", String.Empty);
+            m_rootPart.ToXml(writer);
+            writer.WriteEndElement();
+            writer.WriteStartElement(String.Empty, "OtherParts", String.Empty);
+
+            lock (m_parts)
+            {
+                foreach (SceneObjectPart part in m_parts.Values)
+                {
+                    if (part.UUID != m_rootPart.UUID)
+                    {
+                        writer.WriteStartElement(String.Empty, "Part", String.Empty);
+                        part.ToXml(writer);
+                        writer.WriteEndElement();
+                    }
+                }
+            }
+
+            writer.WriteEndElement();
+            writer.WriteEndElement();
+
+            m_log.DebugFormat("[SOG]: Finished serialization of SOG {0}, {1}ms", Name, System.Environment.TickCount - time);
+
+        }
+
+        public string ToXmlString2()
+        {
+            using (StringWriter sw = new StringWriter())
+            {
+                using (XmlTextWriter writer = new XmlTextWriter(sw))
+                {
+                    ToXml2(writer);
+                }
+
+                return sw.ToString();
+            }
+        }
+
+        public void ToXml2(XmlTextWriter writer)
+        {
+            m_log.DebugFormat("[SOG]: Starting serialization of SOG {0} to XML2", Name);
+            int time = System.Environment.TickCount;
+
+            writer.WriteStartElement(String.Empty, "SceneObjectGroup", String.Empty);
+            m_rootPart.ToXml(writer);
+            writer.WriteStartElement(String.Empty, "OtherParts", String.Empty);
+
+            lock (m_parts)
+            {
+                foreach (SceneObjectPart part in m_parts.Values)
+                {
+                    if (part.UUID != m_rootPart.UUID)
+                    {
+                        part.ToXml(writer);
+                    }
+                }
+            }
+
+            writer.WriteEndElement();
+            writer.WriteEndElement();
+            m_log.DebugFormat("[SOG]: Finished serialization of SOG {0} to XML2, {1}ms", Name, System.Environment.TickCount - time);
+        }
+
+        /// <summary>
+        /// Attach this scene object to the given avatar.
+        /// </summary>
+        /// <param name="agentID"></param>
+        /// <param name="attachmentpoint"></param>
+        /// <param name="AttachOffset"></param>
+        public void AttachToAgent(UUID agentID, uint attachmentpoint, Vector3 AttachOffset, bool silent)
+        {
+            ScenePresence avatar = m_scene.GetScenePresence(agentID);
+            if (avatar != null)
+            {
+                // don't attach attachments to child agents
+                if (avatar.IsChildAgent) return;
+
+                DetachFromBackup();
+
+                // Remove from database and parcel prim count
+                //
+                m_scene.DeleteFromStorage(UUID);
+                m_scene.EventManager.TriggerParcelPrimCountTainted();
+
+                m_rootPart.AttachedAvatar = agentID;
+
+                if (m_rootPart.PhysActor != null)
+                {
+                    m_scene.PhysicsScene.RemovePrim(m_rootPart.PhysActor);
+                    m_rootPart.PhysActor = null;
+                }
+
+                AbsolutePosition = AttachOffset;
+                m_rootPart.AttachedPos = AttachOffset;
+                m_rootPart.IsAttachment = true;
+
+                m_rootPart.SetParentLocalId(avatar.LocalId);
+                SetAttachmentPoint(Convert.ToByte(attachmentpoint));
+
+                avatar.AddAttachment(this);
+
+                if (!silent)
+                {
+                    // Killing it here will cause the client to deselect it
+                    // It then reappears on the avatar, deselected
+                    // through the full update below
+                    //
+                    if (IsSelected)
+                    {
+                        m_scene.SendKillObject(m_rootPart.LocalId);
+                    }
+
+                    IsSelected = false; // fudge....
+                    ScheduleGroupForFullUpdate();
+                }
+            }
+        }
+
+        public byte GetAttachmentPoint()
+        {
+            if (m_rootPart != null)
+            {
+                return m_rootPart.Shape.State;
+            }
+            return (byte)0;
+        }
+
+        public void ClearPartAttachmentData()
+        {
+            SetAttachmentPoint((Byte)0);
+        }
+
+        public void DetachToGround()
+        {
+            ScenePresence avatar = m_scene.GetScenePresence(m_rootPart.AttachedAvatar);
+            if (avatar == null)
+                return;
+
+            avatar.RemoveAttachment(this);
+
+            Vector3 detachedpos = new Vector3(127f,127f,127f);
+            if (avatar == null)
+                return;
+
+            detachedpos = avatar.AbsolutePosition;
+
+            AbsolutePosition = detachedpos;
+            m_rootPart.AttachedAvatar = UUID.Zero;
+            m_rootPart.SetParentLocalId(0);
+            SetAttachmentPoint((byte)0);
+            m_rootPart.ApplyPhysics(m_rootPart.GetEffectiveObjectFlags(), m_rootPart.VolumeDetectActive, m_scene.m_physicalPrim);
+            HasGroupChanged = true;
+            RootPart.Rezzed = DateTime.Now;
+            RootPart.RemFlag(PrimFlags.TemporaryOnRez);
+            AttachToBackup();
+            m_scene.EventManager.TriggerParcelPrimCountTainted();
+            m_rootPart.ScheduleFullUpdate();
+            m_rootPart.ClearUndoState();
+        }
+
+        public void DetachToInventoryPrep()
+        {
+            ScenePresence avatar = m_scene.GetScenePresence(m_rootPart.AttachedAvatar);
+            //Vector3 detachedpos = new Vector3(127f, 127f, 127f);
+            if (avatar != null)
+            {
+                //detachedpos = avatar.AbsolutePosition;
+                avatar.RemoveAttachment(this);
+            }
+
+            m_rootPart.AttachedAvatar = UUID.Zero;
+            m_rootPart.SetParentLocalId(0);
+            //m_rootPart.SetAttachmentPoint((byte)0);
+            m_rootPart.IsAttachment = false;
+            AbsolutePosition = m_rootPart.AttachedPos;
+            //m_rootPart.ApplyPhysics(m_rootPart.GetEffectiveObjectFlags(), m_scene.m_physicalPrim);
+            //AttachToBackup();
+            //m_rootPart.ScheduleFullUpdate();
+
+        }
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="part"></param>
+        private void SetPartAsNonRoot(SceneObjectPart part)
+        {
+            part.ParentID = m_rootPart.LocalId;
+            part.ClearUndoState();
+        }
+
+        public override void UpdateMovement()
+        {
+            lock (m_parts)
+            {
+                foreach (SceneObjectPart part in m_parts.Values)
+                {
+                    part.UpdateMovement();
+                }
+            }
+        }
+
+        public float GetTimeDilation()
+        {
+            return m_scene.TimeDilation;
+        }
+
+        /// <summary>
+        /// Added as a way for the storage provider to reset the scene,
+        /// most likely a better way to do this sort of thing but for now...
+        /// </summary>
+        /// <param name="scene"></param>
+        public void SetScene(Scene scene)
+        {
+            m_scene = scene;
+        }
+        
+        /// <summary>
+        /// Set a part to act as the root part for this scene object
+        /// </summary>
+        /// <param name="part"></param>
+        public void SetRootPart(SceneObjectPart part)
+        {            
+            part.SetParent(this);
+            m_rootPart = part;
+            if (!IsAttachment)
+                part.ParentID = 0;
+            part.LinkNum = 0;           
+            
+            // No locking required since the SOG should not be in the scene yet - one can't change root parts after
+            // the scene object has been attached to the scene
+            m_parts.Add(m_rootPart.UUID, m_rootPart);
+        }        
+
+        /// <summary>
+        /// Add a new part to this scene object.  The part must already be correctly configured.
+        /// </summary>
+        /// <param name="part"></param>
+        public void AddPart(SceneObjectPart part)
+        {
+            lock (m_parts)
+            {
+                part.SetParent(this);
+                m_parts.Add(part.UUID, part);
+
+                part.LinkNum = m_parts.Count;
+
+                if (part.LinkNum == 2 && RootPart != null)
+                    RootPart.LinkNum = 1;
+            }
+        }
+
+        /// <summary>
+        /// Make sure that every non root part has the proper parent root part local id
+        /// </summary>
+        private void UpdateParentIDs()
+        {
+            lock (m_parts)
+            {
+                foreach (SceneObjectPart part in m_parts.Values)
+                {
+                    if (part.UUID != m_rootPart.UUID)
+                    {
+                        part.ParentID = m_rootPart.LocalId;
+                    }
+                }
+            }
+        }
+
+        public void RegenerateFullIDs()
+        {
+            lock (m_parts)
+            {
+                foreach (SceneObjectPart part in m_parts.Values)
+                {
+                    part.UUID = UUID.Random();
+
+                }
+            }
+        }
+        // helper provided for parts.
+        public int GetSceneMaxUndo()
+        {
+            if (m_scene != null)
+                return m_scene.MaxUndoCount;
+            return 5;
+        }
+
+        // justincc: I don't believe this hack is needed any longer, especially since the physics
+        // parts of set AbsolutePosition were already commented out.  By changing HasGroupChanged to false
+        // this method was preventing proper reload of scene objects.
+        // dahlia: I had to uncomment it, without it meshing was failing on some prims and objects
+        // at region startup
+        public void ResetChildPrimPhysicsPositions()
+        {
+            AbsolutePosition = AbsolutePosition; // could someone in the know please explain how this works?
+        }
+
+        public UUID GetPartsFullID(uint localID)
+        {
+            SceneObjectPart part = GetChildPart(localID);
+            if (part != null)
+            {
+                return part.UUID;
+            }
+            return UUID.Zero;
+        }
+
+        public void ObjectGrabHandler(uint localId, Vector3 offsetPos, IClientAPI remoteClient)
+        {
+            if (m_rootPart.LocalId == localId)
+            {
+                OnGrabGroup(offsetPos, remoteClient);
+            }
+            else
+            {
+                SceneObjectPart part = GetChildPart(localId);
+                OnGrabPart(part, offsetPos, remoteClient);
+
+            }
+        }
+
+        public virtual void OnGrabPart(SceneObjectPart part, Vector3 offsetPos, IClientAPI remoteClient)
+        {
+            part.StoreUndoState();
+            part.OnGrab(offsetPos, remoteClient);
+        }
+
+        public virtual void OnGrabGroup(Vector3 offsetPos, IClientAPI remoteClient)
+        {
+            m_scene.EventManager.TriggerGroupGrab(UUID, offsetPos, remoteClient.AgentId);
+        }
+
+        /// <summary>
+        /// Delete this group from its scene and tell all the scene presences about that deletion.
+        /// </summary>        
+        /// <param name="silent">Broadcast deletions to all clients.</param>
+        public void DeleteGroup(bool silent)
+        {
+            // We need to keep track of this state in case this group is still queued for backup.
+            m_isDeleted = true;
+
+            DetachFromBackup();
+
+            lock (m_parts)
+            {
+                foreach (SceneObjectPart part in m_parts.Values)
+                {
+//                    part.Inventory.RemoveScriptInstances();
+
+                    List<ScenePresence> avatars = Scene.GetScenePresences();
+                    for (int i = 0; i < avatars.Count; i++)
+                    {
+                        if (avatars[i].ParentID == LocalId)
+                        {
+                            avatars[i].StandUp();
+                        }
+
+                        if (!silent)
+                        {
+                            if (m_rootPart != null && part == m_rootPart)
+                                avatars[i].ControllingClient.SendKillObject(m_regionHandle, part.LocalId);
+                        }
+                    }
+                }
+            }
+        }
+
+        public void AddScriptLPS(int count)
+        {
+            if (scriptScore + count >= float.MaxValue - count)
+                scriptScore = 0;
+
+            scriptScore += (float)count;
+            SceneGraph d = m_scene.m_sceneGraph;
+            d.AddToScriptLPS(count);
+        }
+
+        public void AddActiveScriptCount(int count)
+        {
+            SceneGraph d = m_scene.m_sceneGraph;
+            d.AddActiveScripts(count);
+        }
+
+        public void aggregateScriptEvents()
+        {
+            uint objectflagupdate=(uint)RootPart.GetEffectiveObjectFlags();
+
+            scriptEvents aggregateScriptEvents=0;
+
+            lock (m_parts)
+            {
+                foreach (SceneObjectPart part in m_parts.Values)
+                {
+                    if (part == null)
+                        continue;
+                    if (part != RootPart)
+                        part.ObjectFlags = objectflagupdate;
+                    aggregateScriptEvents |= part.AggregateScriptEvents;
+                }
+            }
+
+            if ((aggregateScriptEvents & scriptEvents.at_target) != 0)
+            {
+                m_scriptListens_atTarget = true;
+            }
+            else
+            {
+                m_scriptListens_atTarget = false;
+            }
+
+            if ((aggregateScriptEvents & scriptEvents.not_at_target) != 0)
+            {
+                m_scriptListens_notAtTarget = true;
+            }
+            else
+            {
+                m_scriptListens_notAtTarget = false;
+            }
+
+            if (m_scriptListens_atTarget || m_scriptListens_notAtTarget)
+            {
+            }
+            else
+            {
+                lock (m_targets)
+                    m_targets.Clear();
+            }
+
+            ScheduleGroupForFullUpdate();
+        }
+
+        public override void SetText(string text, Vector3 color, double alpha)
+        {
+            Color = Color.FromArgb(0xff - (int) (alpha * 0xff),
+                                   (int) (color.X * 0xff),
+                                   (int) (color.Y * 0xff),
+                                   (int) (color.Z * 0xff));
+            Text = text;
+
+            HasGroupChanged = true;
+            m_rootPart.ScheduleFullUpdate();
+        }
+
+        /// <summary>
+        /// Apply physics to this group
+        /// </summary>
+        /// <param name="m_physicalPrim"></param>
+        public void ApplyPhysics(bool m_physicalPrim)
+        {
+            lock (m_parts)
+            {
+                if (m_parts.Count > 1)
+                {
+                    m_rootPart.ApplyPhysics(m_rootPart.GetEffectiveObjectFlags(), m_rootPart.VolumeDetectActive, m_physicalPrim);
+                    foreach (SceneObjectPart part in m_parts.Values)
+                    {
+                        if (part.LocalId != m_rootPart.LocalId)
+                        {
+                            part.ApplyPhysics(m_rootPart.GetEffectiveObjectFlags(), part.VolumeDetectActive, m_physicalPrim);
+                        }                                                  
+                    }    
+                    
+                    // Hack to get the physics scene geometries in the right spot
+                    ResetChildPrimPhysicsPositions();                     
+                }
+                else
+                {
+                    m_rootPart.ApplyPhysics(m_rootPart.GetEffectiveObjectFlags(), m_rootPart.VolumeDetectActive, m_physicalPrim);
+                }
+            }
+        }
+
+        public void SetOwnerId(UUID userId)
+        {
+            ForEachPart(delegate(SceneObjectPart part) { part.OwnerID = userId; });
+        }
+
+        public void ForEachPart(Action<SceneObjectPart> whatToDo)
+        {
+            lock (m_parts)
+            {
+                foreach (SceneObjectPart part in m_parts.Values)
+                {
+                    whatToDo(part);
+                }
+            }
+        }
+
+        #region Events
+
+        /// <summary>
+        /// Processes backup.
+        /// </summary>
+        /// <param name="datastore"></param>
+        public void ProcessBackup(IRegionDataStore datastore, bool forcedBackup)
+        {
+            if (!m_isBackedUp)
+                return;
+
+            // Since this is the top of the section of call stack for backing up a particular scene object, don't let
+            // any exception propogate upwards.
+
+            if (IsDeleted || UUID == UUID.Zero)
+                return;
+
+            try
+            {
+                if (!m_scene.ShuttingDown) // if shutting down then there will be nothing to handle the return so leave till next restart
+                {
+                    ILandObject parcel = m_scene.LandChannel.GetLandObject(
+                            m_rootPart.GroupPosition.X, m_rootPart.GroupPosition.Y);
+
+                    if (parcel != null && parcel.landData != null &&
+                            parcel.landData.OtherCleanTime != 0)
+                    {
+                        if (parcel.landData.OwnerID != OwnerID &&
+                                (parcel.landData.GroupID != GroupID ||
+                                parcel.landData.GroupID == UUID.Zero))
+                        {
+                            if ((DateTime.Now - RootPart.Rezzed).TotalMinutes >
+                                    parcel.landData.OtherCleanTime)
+                            {
+                                DetachFromBackup();
+                                m_log.InfoFormat("[SCENE]: Returning object {0} due to parcel auto return", RootPart.UUID.ToString());
+                                m_scene.AddReturn(OwnerID, Name, AbsolutePosition, "parcel auto return");
+                                m_scene.DeRezObject(null, RootPart.LocalId,
+                                    RootPart.GroupID, DeRezAction.Return, UUID.Zero);
+
+                                return;
+                            }
+                        }
+                    }
+                }
+
+                if (HasGroupChanged)
+                {
+                    // don't backup while it's selected or you're asking for changes mid stream.
+                    if ((isTimeToPersist()) || (forcedBackup))
+                    {
+                        m_log.DebugFormat(
+                            "[SCENE]: Storing {0}, {1} in {2}",
+                            Name, UUID, m_scene.RegionInfo.RegionName);
+
+                        SceneObjectGroup backup_group = Copy(OwnerID, GroupID, false);
+                        backup_group.RootPart.Velocity = RootPart.Velocity;
+                        backup_group.RootPart.Acceleration = RootPart.Acceleration;
+                        backup_group.RootPart.AngularVelocity = RootPart.AngularVelocity;
+                        backup_group.RootPart.ParticleSystem = RootPart.ParticleSystem;
+                        HasGroupChanged = false;
+
+                        datastore.StoreObject(backup_group, m_scene.RegionInfo.RegionID);
+
+                        backup_group.ForEachPart(delegate(SceneObjectPart part) 
+                        { 
+                            part.Inventory.ProcessInventoryBackup(datastore); 
+                        });
+
+                        backup_group = null;
+                    }
+    //                else
+    //                {
+    //                    m_log.DebugFormat(
+    //                        "[SCENE]: Did not update persistence of object {0} {1}, selected = {2}",
+    //                        Name, UUID, IsSelected);
+    //                }
+                }
+            }
+            catch (Exception e)
+            {
+                m_log.ErrorFormat(
+                    "[SCENE]: Storing of {0}, {1} in {2} failed with exception {3}\n\t{4}", 
+                    Name, UUID, m_scene.RegionInfo.RegionName, e, e.StackTrace);
+            }
+        }
+
+        #endregion
+
+        #region Client Updating
+
+        public void SendFullUpdateToClient(IClientAPI remoteClient)
+        {
+            SendPartFullUpdate(remoteClient, RootPart, m_scene.Permissions.GenerateClientFlags(remoteClient.AgentId, RootPart.UUID));
+
+            lock (m_parts)
+            {
+                foreach (SceneObjectPart part in m_parts.Values)
+                {
+                    if (part != RootPart)
+                        SendPartFullUpdate(remoteClient, part, m_scene.Permissions.GenerateClientFlags(remoteClient.AgentId, part.UUID));
+                }
+            }
+        }
+
+        /// <summary>
+        /// Send a full update to the client for the given part
+        /// </summary>
+        /// <param name="remoteClient"></param>
+        /// <param name="part"></param>
+        internal void SendPartFullUpdate(IClientAPI remoteClient, SceneObjectPart part, uint clientFlags)
+        {
+            if (m_rootPart != null && m_rootPart.UUID == part.UUID)
+            {
+                if (IsAttachment)
+                {
+                    part.SendFullUpdateToClient(remoteClient, m_rootPart.AttachedPos, clientFlags);
+                }
+                else
+                {
+                    part.SendFullUpdateToClient(remoteClient, AbsolutePosition, clientFlags);
+                }
+            }
+            else
+            {
+                part.SendFullUpdateToClient(remoteClient, clientFlags);
+            }
+        }
+
+        #endregion
+
+        #region Copying
+
+        /// <summary>
+        /// Duplicates this object, including operations such as physics set up and attaching to the backup event.
+        /// </summary>
+        /// <returns></returns>
+        public SceneObjectGroup Copy(UUID cAgentID, UUID cGroupID, bool userExposed)
+        {
+            SceneObjectGroup dupe = (SceneObjectGroup)MemberwiseClone();
+            dupe.m_isBackedUp = false;
+            dupe.m_parts = new Dictionary<UUID, SceneObjectPart>();
+            dupe.AbsolutePosition = new Vector3(AbsolutePosition.X, AbsolutePosition.Y, AbsolutePosition.Z);
+
+            dupe.CopyRootPart(m_rootPart, OwnerID, GroupID, userExposed);
+            dupe.m_rootPart.LinkNum = m_rootPart.LinkNum;
+
+            if (userExposed)
+                dupe.m_rootPart.TrimPermissions();
+
+            /// may need to create a new Physics actor.
+            if (dupe.RootPart.PhysActor != null && userExposed)
+            {
+                PrimitiveBaseShape pbs = dupe.RootPart.Shape;
+
+                dupe.RootPart.PhysActor = m_scene.PhysicsScene.AddPrimShape(
+                    dupe.RootPart.Name,
+                    pbs,
+                    new PhysicsVector(dupe.RootPart.AbsolutePosition.X, dupe.RootPart.AbsolutePosition.Y, dupe.RootPart.AbsolutePosition.Z),
+                    new PhysicsVector(dupe.RootPart.Scale.X, dupe.RootPart.Scale.Y, dupe.RootPart.Scale.Z),
+                    dupe.RootPart.RotationOffset,
+                    dupe.RootPart.PhysActor.IsPhysical);
+
+                dupe.RootPart.PhysActor.LocalID = dupe.RootPart.LocalId;
+                dupe.RootPart.DoPhysicsPropertyUpdate(dupe.RootPart.PhysActor.IsPhysical, true);
+            }
+
+            // Now we've made a copy that replaces this one, we need to
+            // switch the owner to the person who did the copying
+            // Second Life copies an object and duplicates the first one in it's place
+            // So, we have to make a copy of this one, set it in it's place then set the owner on this one
+            if (userExposed)
+            {
+                SetRootPartOwner(m_rootPart, cAgentID, cGroupID);
+                m_rootPart.ScheduleFullUpdate();
+            }
+            
+            List<SceneObjectPart> partList;
+
+            lock (m_parts)
+            {                
+                partList = new List<SceneObjectPart>(m_parts.Values);
+            }
+            
+            partList.Sort(delegate(SceneObjectPart p1, SceneObjectPart p2)
+                {
+                    return p1.LinkNum.CompareTo(p2.LinkNum);
+                }
+            );
+
+            foreach (SceneObjectPart part in partList)
+            {
+                if (part.UUID != m_rootPart.UUID)
+                {
+                    SceneObjectPart newPart = dupe.CopyPart(part, OwnerID, GroupID, userExposed);
+
+                    newPart.LinkNum = part.LinkNum;
+
+                    if (userExposed)
+                    {
+                        SetPartOwner(newPart, cAgentID, cGroupID);
+                        newPart.ScheduleFullUpdate();
+                    }
+                }
+            }
+
+            if (userExposed)
+            {
+                dupe.UpdateParentIDs();
+                dupe.HasGroupChanged = true;
+                dupe.AttachToBackup();
+
+                ScheduleGroupForFullUpdate();
+            }
+
+            return dupe;
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="part"></param>
+        /// <param name="cAgentID"></param>
+        /// <param name="cGroupID"></param>
+        public void CopyRootPart(SceneObjectPart part, UUID cAgentID, UUID cGroupID, bool userExposed)
+        {
+            SetRootPart(part.Copy(m_scene.AllocateLocalId(), OwnerID, GroupID, m_parts.Count, userExposed));
+        }
+
+        public void ScriptSetPhysicsStatus(bool UsePhysics)
+        {
+            bool IsTemporary = ((RootPart.Flags & PrimFlags.TemporaryOnRez) != 0);
+            bool IsPhantom = ((RootPart.Flags & PrimFlags.Phantom) != 0);
+            bool IsVolumeDetect = RootPart.VolumeDetectActive;
+            UpdatePrimFlags(RootPart.LocalId, UsePhysics, IsTemporary, IsPhantom, IsVolumeDetect);
+        }
+
+        public void ScriptSetTemporaryStatus(bool TemporaryStatus)
+        {
+            bool UsePhysics = ((RootPart.Flags & PrimFlags.Physics) != 0);
+            bool IsPhantom = ((RootPart.Flags & PrimFlags.Phantom) != 0);
+            bool IsVolumeDetect = RootPart.VolumeDetectActive;
+            UpdatePrimFlags(RootPart.LocalId, UsePhysics, TemporaryStatus, IsPhantom, IsVolumeDetect);
+        }
+
+        public void ScriptSetPhantomStatus(bool PhantomStatus)
+        {
+            bool UsePhysics = ((RootPart.Flags & PrimFlags.Physics) != 0);
+            bool IsTemporary = ((RootPart.Flags & PrimFlags.TemporaryOnRez) != 0);
+            bool IsVolumeDetect = RootPart.VolumeDetectActive;
+            UpdatePrimFlags(RootPart.LocalId, UsePhysics, IsTemporary, PhantomStatus, IsVolumeDetect);
+        }
+
+        public void ScriptSetVolumeDetect(bool VDStatus)
+        {
+            bool UsePhysics = ((RootPart.Flags & PrimFlags.Physics) != 0);
+            bool IsTemporary = ((RootPart.Flags & PrimFlags.TemporaryOnRez) != 0);
+            bool IsPhantom = ((RootPart.Flags & PrimFlags.Phantom) != 0);
+            UpdatePrimFlags(RootPart.LocalId, UsePhysics, IsTemporary, IsPhantom, VDStatus);
+
+            /*
+            ScriptSetPhantomStatus(false);  // What ever it was before, now it's not phantom anymore
+
+            if (PhysActor != null) // Should always be the case now
+            {
+                PhysActor.SetVolumeDetect(param);
+            }
+            if (param != 0)
+                AddFlag(PrimFlags.Phantom);
+
+            ScheduleFullUpdate();
+            */
+        }
+
+        public void applyImpulse(PhysicsVector impulse)
+        {
+            // We check if rootpart is null here because scripts don't delete if you delete the host.
+            // This means that unfortunately, we can pass a null physics actor to Simulate!
+            // Make sure we don't do that!
+            SceneObjectPart rootpart = m_rootPart;
+            if (rootpart != null)
+            {
+                if (rootpart.PhysActor != null)
+                {
+                    if (IsAttachment)
+                    {
+                        ScenePresence avatar = m_scene.GetScenePresence(rootpart.AttachedAvatar);
+                        if (avatar != null)
+                        {
+                            avatar.PushForce(impulse);
+                        }
+                    }
+                    else
+                    {
+                        rootpart.PhysActor.AddForce(impulse,true);
+                        m_scene.PhysicsScene.AddPhysicsActorTaint(rootpart.PhysActor);
+                    }
+                }
+            }
+        }
+
+        public void applyAngularImpulse(PhysicsVector impulse)
+        {
+            // We check if rootpart is null here because scripts don't delete if you delete the host.
+            // This means that unfortunately, we can pass a null physics actor to Simulate!
+            // Make sure we don't do that!
+            SceneObjectPart rootpart = m_rootPart;
+            if (rootpart != null)
+            {
+                if (rootpart.PhysActor != null)
+                {
+                    if (!IsAttachment)
+                    {
+                        rootpart.PhysActor.AddAngularForce(impulse, true);
+                        m_scene.PhysicsScene.AddPhysicsActorTaint(rootpart.PhysActor);
+                    }
+                }
+            }
+        }
+
+        public void setAngularImpulse(PhysicsVector impulse)
+        {
+            // We check if rootpart is null here because scripts don't delete if you delete the host.
+            // This means that unfortunately, we can pass a null physics actor to Simulate!
+            // Make sure we don't do that!
+            SceneObjectPart rootpart = m_rootPart;
+            if (rootpart != null)
+            {
+                if (rootpart.PhysActor != null)
+                {
+                    if (!IsAttachment)
+                    {
+                        rootpart.PhysActor.Torque = impulse;
+                        m_scene.PhysicsScene.AddPhysicsActorTaint(rootpart.PhysActor);
+                    }
+                }
+            }
+        }
+
+        public Vector3 GetTorque()
+        {
+            // We check if rootpart is null here because scripts don't delete if you delete the host.
+            // This means that unfortunately, we can pass a null physics actor to Simulate!
+            // Make sure we don't do that!
+            SceneObjectPart rootpart = m_rootPart;
+            if (rootpart != null)
+            {
+                if (rootpart.PhysActor != null)
+                {
+                    if (!IsAttachment)
+                    {
+                        PhysicsVector torque = rootpart.PhysActor.Torque;
+                        return new Vector3(torque.X, torque.Y, torque.Z);
+                    }
+                }
+            }
+            return Vector3.Zero;
+        }
+
+        public void moveToTarget(Vector3 target, float tau)
+        {
+            SceneObjectPart rootpart = m_rootPart;
+            if (rootpart != null)
+            {
+                if (rootpart.PhysActor != null)
+                {
+                    rootpart.PhysActor.PIDTarget = new PhysicsVector(target.X, target.Y, target.Z);
+                    rootpart.PhysActor.PIDTau = tau;
+                    rootpart.PhysActor.PIDActive = true;
+                }
+            }
+        }
+
+        public void stopMoveToTarget()
+        {
+            SceneObjectPart rootpart = m_rootPart;
+            if (rootpart != null)
+            {
+                if (rootpart.PhysActor != null)
+                {
+                    rootpart.PhysActor.PIDActive = false;
+                }
+            }
+        }
+
+        /// <summary>
+        /// Set the owner of the root part.
+        /// </summary>
+        /// <param name="part"></param>
+        /// <param name="cAgentID"></param>
+        /// <param name="cGroupID"></param>
+        public void SetRootPartOwner(SceneObjectPart part, UUID cAgentID, UUID cGroupID)
+        {
+            part.LastOwnerID = part.OwnerID;
+            part.OwnerID = cAgentID;
+            part.GroupID = cGroupID;
+
+            if (part.OwnerID != cAgentID)
+            {
+                // Apply Next Owner Permissions if we're not bypassing permissions
+                if (!m_scene.Permissions.BypassPermissions())
+                    ApplyNextOwnerPermissions();
+            }
+
+            part.ScheduleFullUpdate();
+        }
+
+        /// <summary>
+        /// Make a copy of the given part.
+        /// </summary>
+        /// <param name="part"></param>
+        /// <param name="cAgentID"></param>
+        /// <param name="cGroupID"></param>
+        public SceneObjectPart CopyPart(SceneObjectPart part, UUID cAgentID, UUID cGroupID, bool userExposed)
+        {
+            SceneObjectPart newPart = part.Copy(m_scene.AllocateLocalId(), OwnerID, GroupID, m_parts.Count, userExposed);
+            newPart.SetParent(this);
+
+            lock (m_parts)
+            {
+                m_parts.Add(newPart.UUID, newPart);
+            }
+
+            SetPartAsNonRoot(newPart);
+
+            return newPart;
+        }
+
+        /// <summary>
+        /// Reset the UUIDs for all the prims that make up this group.
+        ///
+        /// This is called by methods which want to add a new group to an existing scene, in order
+        /// to ensure that there are no clashes with groups already present.
+        /// </summary>
+        public void ResetIDs()
+        {
+            // As this is only ever called for prims which are not currently part of the scene (and hence
+            // not accessible by clients), there should be no need to lock
+            List<SceneObjectPart> partsList = new List<SceneObjectPart>(m_parts.Values);
+            m_parts.Clear();
+            foreach (SceneObjectPart part in partsList)
+            {
+                part.ResetIDs(part.LinkNum); // Don't change link nums
+                m_parts.Add(part.UUID, part);
+            }
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="part"></param>
+        public void ServiceObjectPropertiesFamilyRequest(IClientAPI remoteClient, UUID AgentID, uint RequestFlags)
+        {
+
+            remoteClient.SendObjectPropertiesFamilyData(RequestFlags, RootPart.UUID, RootPart.ObjectOwner, RootPart.GroupID, RootPart.BaseMask,
+                                                        RootPart.OwnerMask, RootPart.GroupMask, RootPart.EveryoneMask, RootPart.NextOwnerMask,
+                                                        RootPart.OwnershipCost, RootPart.ObjectSaleType, RootPart.SalePrice, RootPart.Category,
+                                                        RootPart.CreatorID, RootPart.Name, RootPart.Description);
+        }
+
+        public void SetPartOwner(SceneObjectPart part, UUID cAgentID, UUID cGroupID)
+        {
+            part.OwnerID = cAgentID;
+            part.GroupID = cGroupID;
+        }
+
+        #endregion
+
+        #region Scheduling
+
+        public override void Update()
+        {
+            // Check that the group was not deleted before the scheduled update
+            // FIXME: This is merely a temporary measure to reduce the incidence of failure when
+            // an object has been deleted from a scene before update was processed.
+            // A more fundamental overhaul of the update mechanism is required to eliminate all
+            // the race conditions.
+            if (m_isDeleted)
+                return;
+
+            // This is what happens when an orphanced link set child prim's
+            // group was queued when it was linked
+            //
+            if (m_rootPart == null)
+                return;
+
+            lock (m_parts)
+            {
+                bool UsePhysics = ((RootPart.Flags & PrimFlags.Physics) != 0);
+
+                //if (IsAttachment)
+                //{
+                    //foreach (SceneObjectPart part in m_parts.Values)
+                    //{
+                        //part.SendScheduledUpdates();
+                    //}
+                    //return;
+                //}
+
+                if ((Util.GetDistanceTo(lastPhysGroupPos, AbsolutePosition) > 0.02) && UsePhysics)
+                {
+                    m_rootPart.UpdateFlag = 1;
+                    lastPhysGroupPos = AbsolutePosition;
+                }
+                    //foreach (SceneObjectPart part in m_parts.Values)
+                    //{
+                        //if (part.UpdateFlag == 0) part.UpdateFlag = 1;
+                    //}
+
+                checkAtTargets();
+
+                if (((Math.Abs(lastPhysGroupRot.W - GroupRotation.W) > 0.1)
+                    || (Math.Abs(lastPhysGroupRot.X - GroupRotation.X) > 0.1)
+                    || (Math.Abs(lastPhysGroupRot.Y - GroupRotation.Y) > 0.1)
+                    || (Math.Abs(lastPhysGroupRot.Z - GroupRotation.Z) > 0.1))
+                    && UsePhysics)
+                {
+                    m_rootPart.UpdateFlag = 1;
+
+                    lastPhysGroupRot = GroupRotation;
+                }
+
+                foreach (SceneObjectPart part in m_parts.Values)
+                {
+                    part.SendScheduledUpdates();
+                }
+            }
+        }
+
+        public void ScheduleFullUpdateToAvatar(ScenePresence presence)
+        {
+            RootPart.AddFullUpdateToAvatar(presence);
+
+            lock (m_parts)
+            {
+                foreach (SceneObjectPart part in m_parts.Values)
+                {
+                    if (part != RootPart)
+                        part.AddFullUpdateToAvatar(presence);
+                }
+            }
+        }
+
+        public void ScheduleTerseUpdateToAvatar(ScenePresence presence)
+        {
+            lock (m_parts)
+            {
+                foreach (SceneObjectPart part in m_parts.Values)
+                {
+                    part.AddTerseUpdateToAvatar(presence);
+                }
+            }
+        }
+
+        /// <summary>
+        /// Schedule a full update for this scene object
+        /// </summary>
+        public void ScheduleGroupForFullUpdate()
+        {
+            checkAtTargets();
+            RootPart.ScheduleFullUpdate();
+
+            lock (m_parts)
+            {
+                foreach (SceneObjectPart part in m_parts.Values)
+                {
+                    if (part != RootPart)
+                        part.ScheduleFullUpdate();
+                }
+            }
+        }
+
+        /// <summary>
+        /// Schedule a terse update for this scene object
+        /// </summary>
+        public void ScheduleGroupForTerseUpdate()
+        {
+            lock (m_parts)
+            {
+                foreach (SceneObjectPart part in m_parts.Values)
+                {
+                    part.ScheduleTerseUpdate();
+                }
+            }
+        }
+
+        /// <summary>
+        /// Immediately send a full update for this scene object.
+        /// </summary>
+        public void SendGroupFullUpdate()
+        {
+            if (IsDeleted)
+                return;
+            
+            RootPart.SendFullUpdateToAllClients();
+
+            lock (m_parts)
+            {
+                foreach (SceneObjectPart part in m_parts.Values)
+                {
+                    if (part != RootPart)
+                        part.SendFullUpdateToAllClients();
+                }
+            }
+        }
+
+        /// <summary>
+        /// Immediately send an update for this scene object's root prim only.
+        /// This is for updates regarding the object as a whole, and none of its parts in particular.
+        /// Note: this may not be cused by opensim (it probably should) but it's used by
+        /// external modules.
+        /// </summary>
+        public void SendGroupRootUpdate()
+        {
+            if (IsDeleted)
+                return;
+
+            RootPart.SendFullUpdateToAllClients();
+        }
+
+        public void QueueForUpdateCheck()
+        {
+            if (m_scene == null) // Need to check here as it's null during object creation
+                return;
+            m_scene.m_sceneGraph.AddToUpdateList(this);
+        }
+
+        /// <summary>
+        /// Immediately send a terse update for this scene object.
+        /// </summary>
+        public void SendGroupTerseUpdate()
+        {
+            if (IsDeleted)
+                return;
+            
+            lock (m_parts)
+            {
+                foreach (SceneObjectPart part in m_parts.Values)
+                {
+                    part.SendTerseUpdateToAllClients();
+                }
+            }
+        }
+
+        #endregion
+
+        #region SceneGroupPart Methods
+
+        /// <summary>
+        /// Get the child part by LinkNum
+        /// </summary>
+        /// <param name="linknum"></param>
+        /// <returns>null if no child part with that linknum or child part</returns>
+        public SceneObjectPart GetLinkNumPart(int linknum)
+        {
+            lock (m_parts)
+            {
+                foreach (SceneObjectPart part in m_parts.Values)
+                {
+                    if (part.LinkNum == linknum)
+                    {
+                        return part;
+                    }
+                }
+            }
+
+            return null;
+        }
+
+        /// <summary>
+        /// Get a child part with a given UUID
+        /// </summary>
+        /// <param name="primID"></param>
+        /// <returns>null if a child part with the primID was not found</returns>
+        public SceneObjectPart GetChildPart(UUID primID)
+        {
+            SceneObjectPart childPart = null;
+            if (m_parts.ContainsKey(primID))
+            {
+                childPart = m_parts[primID];
+            }
+            return childPart;
+        }
+
+        /// <summary>
+        /// Get a child part with a given local ID
+        /// </summary>
+        /// <param name="localID"></param>
+        /// <returns>null if a child part with the local ID was not found</returns>
+        public SceneObjectPart GetChildPart(uint localID)
+        {
+            //m_log.DebugFormat("Entered looking for {0}", localID);
+            lock (m_parts)
+            {
+                foreach (SceneObjectPart part in m_parts.Values)
+                {
+                    //m_log.DebugFormat("Found {0}", part.LocalId);
+                    if (part.LocalId == localID)
+                    {
+                        return part;
+                    }
+                }
+            }
+
+            return null;
+        }
+
+        /// <summary>
+        /// Does this group contain the child prim
+        /// should be able to remove these methods once we have a entity index in scene
+        /// </summary>
+        /// <param name="primID"></param>
+        /// <returns></returns>
+        public bool HasChildPrim(UUID primID)
+        {
+            if (m_parts.ContainsKey(primID))
+            {
+                return true;
+            }
+
+            return false;
+        }
+
+        /// <summary>
+        /// Does this group contain the child prim
+        /// should be able to remove these methods once we have a entity index in scene
+        /// </summary>
+        /// <param name="localID"></param>
+        /// <returns></returns>
+        public bool HasChildPrim(uint localID)
+        {
+            //m_log.DebugFormat("Entered HasChildPrim looking for {0}", localID);
+            lock (m_parts)
+            {
+                foreach (SceneObjectPart part in m_parts.Values)
+                {
+                    //m_log.DebugFormat("Found {0}", part.LocalId);
+                    if (part.LocalId == localID)
+                    {
+                        return true;
+                    }
+                }
+            }
+
+            return false;
+        }
+
+        #endregion
+
+        #region Packet Handlers
+
+        /// <summary>
+        /// Link the prims in a given group to this group
+        /// </summary>
+        /// <param name="objectGroup">The group of prims which should be linked to this group</param>
+        public void LinkToGroup(SceneObjectGroup objectGroup)
+        {
+            if (objectGroup.RootPart.UpdateFlag > 0)
+            {
+                // I've never actually seen this happen, though I think it's theoretically possible
+                m_log.WarnFormat(
+                    "[SCENE OBJECT GROUP]: Aborted linking {0}, {1} to {2}, {3} as it has yet to finish delinking",
+                    objectGroup.RootPart.Name, objectGroup.RootPart.UUID, RootPart.Name, RootPart.UUID);
+
+                return;
+            }
+
+//            m_log.DebugFormat(
+//                "[SCENE OBJECT GROUP]: Linking group with root part {0}, {1} to group with root part {2}, {3}",
+//                objectGroup.RootPart.Name, objectGroup.RootPart.UUID, RootPart.Name, RootPart.UUID);
+
+            SceneObjectPart linkPart = objectGroup.m_rootPart;
+
+            Vector3 oldGroupPosition = linkPart.GroupPosition;
+            Quaternion oldRootRotation = linkPart.RotationOffset;
+
+            linkPart.OffsetPosition = linkPart.GroupPosition - AbsolutePosition;
+            linkPart.GroupPosition = AbsolutePosition;
+            Vector3 axPos = linkPart.OffsetPosition;
+
+            Quaternion parentRot = m_rootPart.RotationOffset;
+            axPos *= Quaternion.Inverse(parentRot);
+
+            linkPart.OffsetPosition = axPos;
+            Quaternion oldRot = linkPart.RotationOffset;
+            Quaternion newRot = Quaternion.Inverse(parentRot) * oldRot;
+            linkPart.RotationOffset = newRot;
+
+            linkPart.ParentID = m_rootPart.LocalId;
+            if (m_rootPart.LinkNum == 0)
+                m_rootPart.LinkNum = 1;
+
+            lock (m_parts)
+            {
+                m_parts.Add(linkPart.UUID, linkPart);
+
+                // Insert in terms of link numbers, the new links
+                // before the current ones (with the exception of 
+                // the root prim. Shuffle the old ones up
+                foreach (KeyValuePair<UUID, SceneObjectPart> kvp in m_parts) 
+                {
+                    if (kvp.Value.LinkNum != 1)
+                    {
+                        // Don't update root prim link number
+                        kvp.Value.LinkNum += objectGroup.PrimCount;
+                    }
+                }
+
+                linkPart.LinkNum = 2;
+
+                linkPart.SetParent(this);
+                linkPart.AddFlag(PrimFlags.CreateSelected);
+
+                //if (linkPart.PhysActor != null)
+                //{
+                // m_scene.PhysicsScene.RemovePrim(linkPart.PhysActor);
+        
+                //linkPart.PhysActor = null;
+                //}
+
+                //TODO: rest of parts
+                int linkNum = 3;
+                foreach (SceneObjectPart part in objectGroup.Children.Values)
+                {
+                    if (part.UUID != objectGroup.m_rootPart.UUID)
+                    {
+                        LinkNonRootPart(part, oldGroupPosition, oldRootRotation, linkNum++);
+                    }
+                    part.ClearUndoState();
+                }
+            }
+
+            m_scene.UnlinkSceneObject(objectGroup.UUID, true);
+            objectGroup.m_isDeleted = true;
+            
+            lock (objectGroup.m_parts)
+            {
+                objectGroup.m_parts.Clear();
+            }
+            
+            // Can't do this yet since backup still makes use of the root part without any synchronization
+//            objectGroup.m_rootPart = null;
+
+            AttachToBackup();
+            HasGroupChanged = true;
+            ScheduleGroupForFullUpdate();
+        }
+
+        /// <summary>
+        /// Delink the given prim from this group.  The delinked prim is established as
+        /// an independent SceneObjectGroup.
+        /// </summary>
+        /// <param name="partID"></param>
+        public void DelinkFromGroup(uint partID)
+        {
+            DelinkFromGroup(partID, true);
+        }
+
+        /// <summary>
+        /// Delink the given prim from this group.  The delinked prim is established as
+        /// an independent SceneObjectGroup.
+        /// </summary>
+        /// <param name="partID"></param>
+        /// <param name="sendEvents"></param>
+        public void DelinkFromGroup(uint partID, bool sendEvents)
+        {
+            SceneObjectPart linkPart = GetChildPart(partID);
+
+            if (null != linkPart)
+            {
+                linkPart.ClearUndoState();
+//                m_log.DebugFormat(
+//                    "[SCENE OBJECT GROUP]: Delinking part {0}, {1} from group with root part {2}, {3}",
+//                    linkPart.Name, linkPart.UUID, RootPart.Name, RootPart.UUID);
+
+                Quaternion worldRot = linkPart.GetWorldRotation();
+
+                // Remove the part from this object
+                lock (m_parts)
+                {
+                    m_parts.Remove(linkPart.UUID);
+                }
+
+                if (m_parts.Count == 1 && RootPart != null) //Single prim is left
+                    RootPart.LinkNum = 0;
+                else
+                {
+                    foreach (SceneObjectPart p in m_parts.Values)
+                    {
+                        if (p.LinkNum > linkPart.LinkNum)
+                            p.LinkNum--;
+                    }
+                }
+
+                linkPart.ParentID = 0;
+                linkPart.LinkNum = 0;
+
+                if (linkPart.PhysActor != null)
+                {
+                    m_scene.PhysicsScene.RemovePrim(linkPart.PhysActor);
+                }
+
+                // We need to reset the child part's position
+                // ready for life as a separate object after being a part of another object
+                Quaternion parentRot = m_rootPart.RotationOffset;
+
+                Vector3 axPos = linkPart.OffsetPosition;
+
+                axPos *= parentRot;
+                linkPart.OffsetPosition = new Vector3(axPos.X, axPos.Y, axPos.Z);
+                linkPart.GroupPosition = AbsolutePosition + linkPart.OffsetPosition;
+                linkPart.OffsetPosition = new Vector3(0, 0, 0);
+
+                linkPart.RotationOffset = worldRot;
+
+                SceneObjectGroup objectGroup = new SceneObjectGroup(linkPart);
+
+                m_scene.AddNewSceneObject(objectGroup, true);
+
+                if (sendEvents)
+                    linkPart.TriggerScriptChangedEvent(Changed.LINK);
+
+                linkPart.Rezzed = RootPart.Rezzed;
+
+                HasGroupChanged = true;
+                ScheduleGroupForFullUpdate();
+            }
+            else
+            {
+                m_log.InfoFormat("[SCENE OBJECT GROUP]: " +
+                                 "DelinkFromGroup(): Child prim {0} not found in object {1}, {2}",
+                                 partID, LocalId, UUID);
+            }
+        }
+
+        /// <summary>
+        /// Stop this object from being persisted over server restarts.
+        /// </summary>
+        /// <param name="objectGroup"></param>
+        public void DetachFromBackup()
+        {
+            if (m_isBackedUp)
+                m_scene.EventManager.OnBackup -= ProcessBackup;
+            
+            m_isBackedUp = false;
+        }
+
+        private void LinkNonRootPart(SceneObjectPart part, Vector3 oldGroupPosition, Quaternion oldGroupRotation, int linkNum)
+        {
+
+            Quaternion parentRot = oldGroupRotation;
+            Quaternion oldRot = part.RotationOffset;
+            Quaternion worldRot = parentRot * oldRot;
+
+            parentRot = oldGroupRotation;
+
+            Vector3 axPos = part.OffsetPosition;
+
+            axPos *= parentRot;
+            part.OffsetPosition = axPos;
+            part.GroupPosition = oldGroupPosition + part.OffsetPosition;
+            part.OffsetPosition = Vector3.Zero;
+            part.RotationOffset = worldRot;
+
+            part.SetParent(this);
+            part.ParentID = m_rootPart.LocalId;
+
+            // Caller locks m_parts for us
+            m_parts.Add(part.UUID, part);
+
+            part.LinkNum = linkNum;
+
+
+            part.OffsetPosition = part.GroupPosition - AbsolutePosition;
+
+            Quaternion rootRotation = m_rootPart.RotationOffset;
+
+            Vector3 pos = part.OffsetPosition;
+            pos *= Quaternion.Inverse(rootRotation);
+            part.OffsetPosition = pos;
+
+            parentRot = m_rootPart.RotationOffset;
+            oldRot = part.RotationOffset;
+            Quaternion newRot = Quaternion.Inverse(parentRot) * oldRot;
+            part.RotationOffset = newRot;
+        }
+
+        /// <summary>
+        /// If object is physical, apply force to move it around
+        /// If object is not physical, just put it at the resulting location
+        /// </summary>
+        /// <param name="offset">Always seems to be 0,0,0, so ignoring</param>
+        /// <param name="pos">New position.  We do the math here to turn it into a force</param>
+        /// <param name="remoteClient"></param>
+        public void GrabMovement(Vector3 offset, Vector3 pos, IClientAPI remoteClient)
+        {
+            if (m_scene.EventManager.TriggerGroupMove(UUID, pos))
+            {
+                if (m_rootPart.PhysActor != null)
+                {
+                    if (m_rootPart.PhysActor.IsPhysical)
+                    {
+                        Vector3 llmoveforce = pos - AbsolutePosition;
+                        PhysicsVector grabforce = new PhysicsVector(llmoveforce.X, llmoveforce.Y, llmoveforce.Z);
+                        grabforce = (grabforce / 10) * m_rootPart.PhysActor.Mass;
+                        m_rootPart.PhysActor.AddForce(grabforce,true);
+                        m_scene.PhysicsScene.AddPhysicsActorTaint(m_rootPart.PhysActor);
+                    }
+                    else
+                    {
+                        //NonPhysicalGrabMovement(pos);
+                    }
+                }
+                else
+                {
+                    //NonPhysicalGrabMovement(pos);
+                }
+            }
+        }
+
+        public void NonPhysicalGrabMovement(Vector3 pos)
+        {
+            AbsolutePosition = pos;
+            m_rootPart.SendTerseUpdateToAllClients();
+        }
+
+        /// <summary>
+        /// Return metadata about a prim (name, description, sale price, etc.)
+        /// </summary>
+        /// <param name="client"></param>
+        public void GetProperties(IClientAPI client)
+        {
+            m_rootPart.GetProperties(client);
+        }
+
+        /// <summary>
+        /// Set the name of a prim
+        /// </summary>
+        /// <param name="name"></param>
+        /// <param name="localID"></param>
+        public void SetPartName(string name, uint localID)
+        {
+            SceneObjectPart part = GetChildPart(localID);
+            if (part != null)
+            {
+                part.Name = name;
+            }
+        }
+
+        public void SetPartDescription(string des, uint localID)
+        {
+            SceneObjectPart part = GetChildPart(localID);
+            if (part != null)
+            {
+                part.Description = des;
+            }
+        }
+
+        public void SetPartText(string text, uint localID)
+        {
+            SceneObjectPart part = GetChildPart(localID);
+            if (part != null)
+            {
+                part.SetText(text);
+            }
+        }
+
+        public void SetPartText(string text, UUID partID)
+        {
+            SceneObjectPart part = GetChildPart(partID);
+            if (part != null)
+            {
+                part.SetText(text);
+            }
+        }
+
+        public string GetPartName(uint localID)
+        {
+            SceneObjectPart part = GetChildPart(localID);
+            if (part != null)
+            {
+                return part.Name;
+            }
+            return String.Empty;
+        }
+
+        public string GetPartDescription(uint localID)
+        {
+            SceneObjectPart part = GetChildPart(localID);
+            if (part != null)
+            {
+                return part.Description;
+            }
+            return String.Empty;
+        }
+
+        /// <summary>
+        /// Update prim flags for this group.
+        /// </summary>
+        /// <param name="localID"></param>
+        /// <param name="type"></param>
+        /// <param name="inUse"></param>
+        /// <param name="data"></param>
+        public void UpdatePrimFlags(uint localID, bool UsePhysics, bool IsTemporary, bool IsPhantom, bool IsVolumeDetect)
+        {
+            SceneObjectPart selectionPart = GetChildPart(localID);
+
+            if (IsTemporary)
+            {
+                DetachFromBackup();
+                // Remove from database and parcel prim count
+                //
+                m_scene.DeleteFromStorage(UUID);
+                m_scene.EventManager.TriggerParcelPrimCountTainted();
+            }
+
+            if (selectionPart != null)
+            {
+                lock (m_parts)
+                {
+                    foreach (SceneObjectPart part in m_parts.Values)
+                    {
+                        if (part.Scale.X > 10.0 || part.Scale.Y > 10.0 || part.Scale.Z > 10.0)
+                        {
+                            UsePhysics = false; // Reset physics
+                            break;
+                        }
+                    }
+
+                    foreach (SceneObjectPart part in m_parts.Values)
+                    {
+                        part.UpdatePrimFlags(UsePhysics, IsTemporary, IsPhantom, IsVolumeDetect);
+                    }
+                }
+            }
+        }
+
+        public void UpdateExtraParam(uint localID, ushort type, bool inUse, byte[] data)
+        {
+            SceneObjectPart part = GetChildPart(localID);
+            if (part != null)
+            {
+                part.UpdateExtraParam(type, inUse, data);
+            }
+        }
+
+        /// <summary>
+        /// Get the parts of this scene object
+        /// </summary>
+        /// <returns></returns>
+        public SceneObjectPart[] GetParts()
+        {
+            int numParts = Children.Count;
+            SceneObjectPart[] partArray = new SceneObjectPart[numParts];
+            Children.Values.CopyTo(partArray, 0);
+            return partArray;
+        }
+
+        /// <summary>
+        /// Update the texture entry for this part
+        /// </summary>
+        /// <param name="localID"></param>
+        /// <param name="textureEntry"></param>
+        public void UpdateTextureEntry(uint localID, byte[] textureEntry)
+        {
+            SceneObjectPart part = GetChildPart(localID);
+            if (part != null)
+            {
+                part.UpdateTextureEntry(textureEntry);
+            }
+        }
+
+        public void UpdatePermissions(UUID AgentID, byte field, uint localID,
+                uint mask, byte addRemTF)
+        {
+            foreach (SceneObjectPart part in m_parts.Values)
+                part.UpdatePermissions(AgentID, field, localID, mask,
+                        addRemTF);
+
+            HasGroupChanged = true;
+        }
+
+        #endregion
+
+        #region Shape
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="shapeBlock"></param>
+        public void UpdateShape(ObjectShapePacket.ObjectDataBlock shapeBlock, uint localID)
+        {
+            SceneObjectPart part = GetChildPart(localID);
+            if (part != null)
+            {
+                part.UpdateShape(shapeBlock);
+
+                if (part.PhysActor != null)
+                    m_scene.PhysicsScene.AddPhysicsActorTaint(part.PhysActor);
+            }
+        }
+
+        #endregion
+
+        #region Resize
+
+        /// <summary>
+        /// Resize the given part
+        /// </summary>
+        /// <param name="scale"></param>
+        /// <param name="localID"></param>
+        public void Resize(Vector3 scale, uint localID)
+        {
+            if (scale.X > m_scene.m_maxNonphys)
+                scale.X = m_scene.m_maxNonphys;
+            if (scale.Y > m_scene.m_maxNonphys)
+                scale.Y = m_scene.m_maxNonphys;
+            if (scale.Z > m_scene.m_maxNonphys)
+                scale.Z = m_scene.m_maxNonphys;
+
+            SceneObjectPart part = GetChildPart(localID);
+            if (part != null)
+            {
+                part.Resize(scale);
+                if (part.PhysActor != null)
+                {
+                    if (part.PhysActor.IsPhysical)
+                    {
+                        if (scale.X > m_scene.m_maxPhys)
+                            scale.X = m_scene.m_maxPhys;
+                        if (scale.Y > m_scene.m_maxPhys)
+                            scale.Y = m_scene.m_maxPhys;
+                        if (scale.Z > m_scene.m_maxPhys)
+                            scale.Z = m_scene.m_maxPhys;
+                    }
+                    part.PhysActor.Size =
+                        new PhysicsVector(scale.X, scale.Y, scale.Z);
+                    m_scene.PhysicsScene.AddPhysicsActorTaint(part.PhysActor);
+                }
+                //if (part.UUID != m_rootPart.UUID)
+
+                HasGroupChanged = true;
+                ScheduleGroupForFullUpdate();
+
+                //if (part.UUID == m_rootPart.UUID)
+                //{
+                //if (m_rootPart.PhysActor != null)
+                //{
+                //m_rootPart.PhysActor.Size =
+                //new PhysicsVector(m_rootPart.Scale.X, m_rootPart.Scale.Y, m_rootPart.Scale.Z);
+                //m_scene.PhysicsScene.AddPhysicsActorTaint(m_rootPart.PhysActor);
+                //}
+                //}
+            }
+        }
+
+        public void GroupResize(Vector3 scale, uint localID)
+        {
+            SceneObjectPart part = GetChildPart(localID);
+            if (part != null)
+            {
+                if (scale.X > m_scene.m_maxNonphys)
+                    scale.X = m_scene.m_maxNonphys;
+                if (scale.Y > m_scene.m_maxNonphys)
+                    scale.Y = m_scene.m_maxNonphys;
+                if (scale.Z > m_scene.m_maxNonphys)
+                    scale.Z = m_scene.m_maxNonphys;
+                if (part.PhysActor != null && part.PhysActor.IsPhysical)
+                {
+                    if (scale.X > m_scene.m_maxPhys)
+                        scale.X = m_scene.m_maxPhys;
+                    if (scale.Y > m_scene.m_maxPhys)
+                        scale.Y = m_scene.m_maxPhys;
+                    if (scale.Z > m_scene.m_maxPhys)
+                        scale.Z = m_scene.m_maxPhys;
+                }
+                float x = (scale.X / part.Scale.X);
+                float y = (scale.Y / part.Scale.Y);
+                float z = (scale.Z / part.Scale.Z);
+
+                lock (m_parts)
+                {
+                    if (x > 1.0f || y > 1.0f || z > 1.0f)
+                    {
+                        foreach (SceneObjectPart obPart in m_parts.Values)
+                        {
+                            if (obPart.UUID != m_rootPart.UUID)
+                            {
+                                Vector3 oldSize = new Vector3(obPart.Scale);
+
+                                float f = 1.0f;
+                                float a = 1.0f;
+
+                                if (part.PhysActor != null && part.PhysActor.IsPhysical)
+                                {
+                                    if (oldSize.X*x > m_scene.m_maxPhys)
+                                    {
+                                        f = m_scene.m_maxPhys / oldSize.X;
+                                        a = f / x;
+                                        x *= a;
+                                        y *= a;
+                                        z *= a;
+                                    }
+                                    if (oldSize.Y*y > m_scene.m_maxPhys)
+                                    {
+                                        f = m_scene.m_maxPhys / oldSize.Y;
+                                        a = f / y;
+                                        x *= a;
+                                        y *= a;
+                                        z *= a;
+                                    }
+                                    if (oldSize.Z*z > m_scene.m_maxPhys)
+                                    {
+                                        f = m_scene.m_maxPhys / oldSize.Z;
+                                        a = f / z;
+                                        x *= a;
+                                        y *= a;
+                                        z *= a;
+                                    }
+                                }
+                                else
+                                {
+                                    if (oldSize.X*x > m_scene.m_maxNonphys)
+                                    {
+                                        f = m_scene.m_maxNonphys / oldSize.X;
+                                        a = f / x;
+                                        x *= a;
+                                        y *= a;
+                                        z *= a;
+                                    }
+                                    if (oldSize.Y*y > m_scene.m_maxNonphys)
+                                    {
+                                        f = m_scene.m_maxNonphys / oldSize.Y;
+                                        a = f / y;
+                                        x *= a;
+                                        y *= a;
+                                        z *= a;
+                                    }
+                                    if (oldSize.Z*z > m_scene.m_maxNonphys)
+                                    {
+                                        f = m_scene.m_maxNonphys / oldSize.Z;
+                                        a = f / z;
+                                        x *= a;
+                                        y *= a;
+                                        z *= a;
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+
+                Vector3 prevScale = part.Scale;
+                prevScale.X *= x;
+                prevScale.Y *= y;
+                prevScale.Z *= z;
+                part.Resize(prevScale);
+
+                lock (m_parts)
+                {
+                    foreach (SceneObjectPart obPart in m_parts.Values)
+                    {
+                        if (obPart.UUID != m_rootPart.UUID)
+                        {
+                            Vector3 currentpos = new Vector3(obPart.OffsetPosition);
+                            currentpos.X *= x;
+                            currentpos.Y *= y;
+                            currentpos.Z *= z;
+                            Vector3 newSize = new Vector3(obPart.Scale);
+                            newSize.X *= x;
+                            newSize.Y *= y;
+                            newSize.Z *= z;
+                            obPart.Resize(newSize);
+                            obPart.UpdateOffSet(currentpos);
+                        }
+                    }
+                }
+
+                if (part.PhysActor != null)
+                {
+                    part.PhysActor.Size =
+                        new PhysicsVector(prevScale.X, prevScale.Y, prevScale.Z);
+                    m_scene.PhysicsScene.AddPhysicsActorTaint(part.PhysActor);
+                }
+
+                HasGroupChanged = true;
+                ScheduleGroupForTerseUpdate();
+            }
+        }
+
+        #endregion
+
+        #region Position
+
+        /// <summary>
+        /// Move this scene object
+        /// </summary>
+        /// <param name="pos"></param>
+        public void UpdateGroupPosition(Vector3 pos)
+        {
+            if (m_scene.EventManager.TriggerGroupMove(UUID, pos))
+            {
+                if (IsAttachment)
+                {
+                    m_rootPart.AttachedPos = pos;
+                }
+
+                AbsolutePosition = pos;
+
+                HasGroupChanged = true;
+            }
+
+            //we need to do a terse update even if the move wasn't allowed
+            // so that the position is reset in the client (the object snaps back)
+            ScheduleGroupForTerseUpdate();
+        }
+
+        /// <summary>
+        /// Update the position of a single part of this scene object
+        /// </summary>
+        /// <param name="pos"></param>
+        /// <param name="localID"></param>
+        public void UpdateSinglePosition(Vector3 pos, uint localID)
+        {
+            SceneObjectPart part = GetChildPart(localID);
+
+            if (part != null)
+            {
+                if (part.UUID == m_rootPart.UUID)
+                {
+                    UpdateRootPosition(pos);
+                }
+                else
+                {
+                    part.UpdateOffSet(pos);
+                }
+
+                HasGroupChanged = true;
+            }
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="pos"></param>
+        private void UpdateRootPosition(Vector3 pos)
+        {
+            Vector3 newPos = new Vector3(pos.X, pos.Y, pos.Z);
+            Vector3 oldPos =
+                new Vector3(AbsolutePosition.X + m_rootPart.OffsetPosition.X,
+                              AbsolutePosition.Y + m_rootPart.OffsetPosition.Y,
+                              AbsolutePosition.Z + m_rootPart.OffsetPosition.Z);
+            Vector3 diff = oldPos - newPos;
+            Vector3 axDiff = new Vector3(diff.X, diff.Y, diff.Z);
+            Quaternion partRotation = m_rootPart.RotationOffset;
+            axDiff *= Quaternion.Inverse(partRotation);
+            diff = axDiff;
+
+            lock (m_parts)
+            {
+                foreach (SceneObjectPart obPart in m_parts.Values)
+                {
+                    if (obPart.UUID != m_rootPart.UUID)
+                    {
+                        obPart.OffsetPosition = obPart.OffsetPosition + diff;
+                    }
+                }
+            }
+
+            AbsolutePosition = newPos;
+
+            HasGroupChanged = true;
+            ScheduleGroupForTerseUpdate();
+        }
+
+        public void OffsetForNewRegion(Vector3 offset)
+        {
+            m_rootPart.GroupPosition = offset;
+        }
+
+        #endregion
+
+        #region Rotation
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="rot"></param>
+        public void UpdateGroupRotation(Quaternion rot)
+        {
+            m_rootPart.UpdateRotation(rot);
+            if (m_rootPart.PhysActor != null)
+            {
+                m_rootPart.PhysActor.Orientation = m_rootPart.RotationOffset;
+                m_scene.PhysicsScene.AddPhysicsActorTaint(m_rootPart.PhysActor);
+            }
+
+            HasGroupChanged = true;
+            ScheduleGroupForTerseUpdate();
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="pos"></param>
+        /// <param name="rot"></param>
+        public void UpdateGroupRotation(Vector3 pos, Quaternion rot)
+        {
+            m_rootPart.UpdateRotation(rot);
+            if (m_rootPart.PhysActor != null)
+            {
+                m_rootPart.PhysActor.Orientation = m_rootPart.RotationOffset;
+                m_scene.PhysicsScene.AddPhysicsActorTaint(m_rootPart.PhysActor);
+            }
+            AbsolutePosition = pos;
+
+            HasGroupChanged = true;
+            ScheduleGroupForTerseUpdate();
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="rot"></param>
+        /// <param name="localID"></param>
+        public void UpdateSingleRotation(Quaternion rot, uint localID)
+        {
+            SceneObjectPart part = GetChildPart(localID);
+            if (part != null)
+            {
+                if (part.UUID == m_rootPart.UUID)
+                {
+                    UpdateRootRotation(rot);
+                }
+                else
+                {
+                    part.UpdateRotation(rot);
+                }
+            }
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="rot"></param>
+        private void UpdateRootRotation(Quaternion rot)
+        {
+            Quaternion axRot = rot;
+            Quaternion oldParentRot = m_rootPart.RotationOffset;
+
+            m_rootPart.UpdateRotation(rot);
+            if (m_rootPart.PhysActor != null)
+            {
+                m_rootPart.PhysActor.Orientation = m_rootPart.RotationOffset;
+                m_scene.PhysicsScene.AddPhysicsActorTaint(m_rootPart.PhysActor);
+            }
+
+            lock (m_parts)
+            {
+                foreach (SceneObjectPart prim in m_parts.Values)
+                {
+                    if (prim.UUID != m_rootPart.UUID)
+                    {
+                        Vector3 axPos = prim.OffsetPosition;
+                        axPos *= oldParentRot;
+                        axPos *= Quaternion.Inverse(axRot);
+                        prim.OffsetPosition = axPos;
+                        Quaternion primsRot = prim.RotationOffset;
+                        Quaternion newRot = primsRot * oldParentRot;
+                        newRot *= Quaternion.Inverse(axRot);
+                        prim.RotationOffset = newRot;
+                        prim.ScheduleTerseUpdate();
+                    }
+                }
+            }
+
+            m_rootPart.ScheduleTerseUpdate();
+        }
+
+        #endregion
+
+        internal void SetAxisRotation(int axis, int rotate10)
+        {
+            bool setX = false;
+            bool setY = false;
+            bool setZ = false;
+
+            int xaxis = 2;
+            int yaxis = 4;
+            int zaxis = 8;
+
+            if (m_rootPart != null)
+            {
+                setX = ((axis & xaxis) != 0) ? true : false;
+                setY = ((axis & yaxis) != 0) ? true : false;
+                setZ = ((axis & zaxis) != 0) ? true : false;
+
+                float setval = (rotate10 > 0) ? 1f : 0f;
+
+                if (setX)
+                    m_rootPart.RotationAxis.X = setval;
+                if (setY)
+                    m_rootPart.RotationAxis.Y = setval;
+                if (setZ)
+                    m_rootPart.RotationAxis.Z = setval;
+
+                if (setX || setY || setZ)
+                {
+                    m_rootPart.SetPhysicsAxisRotation();
+                }
+
+            }
+        }
+
+        public int registerTargetWaypoint(Vector3 target, float tolerance)
+        {
+            scriptPosTarget waypoint = new scriptPosTarget();
+            waypoint.targetPos = target;
+            waypoint.tolerance = tolerance;
+            uint handle = m_scene.AllocateLocalId();
+            lock (m_targets)
+            {
+                m_targets.Add(handle, waypoint);
+            }
+            return (int)handle;
+        }
+        
+        public void unregisterTargetWaypoint(int handle)
+        {
+            lock (m_targets)
+            {
+                if (m_targets.ContainsKey((uint)handle))
+                    m_targets.Remove((uint)handle);
+            }
+        }
+
+        private void checkAtTargets()
+        {
+            if (m_scriptListens_atTarget || m_scriptListens_notAtTarget)
+            {
+                if (m_targets.Count > 0)
+                {
+                    bool at_target = false;
+                    //Vector3 targetPos;
+                    //uint targetHandle;
+                    Dictionary<uint, scriptPosTarget> atTargets = new Dictionary<uint, scriptPosTarget>();
+                    lock (m_targets)
+                    {
+                        foreach (uint idx in m_targets.Keys)
+                        {
+                            scriptPosTarget target = m_targets[idx];
+                            if (Util.GetDistanceTo(target.targetPos, m_rootPart.GroupPosition) <= target.tolerance)
+                            {
+                                // trigger at_target
+                                if (m_scriptListens_atTarget)
+                                {
+                                    // Reusing att.tolerance to hold the index of the target in the targets dictionary
+                                    // to avoid deadlocking the sim.
+                                    at_target = true;
+                                    scriptPosTarget att = new scriptPosTarget();
+                                    att.targetPos = target.targetPos;
+                                    att.tolerance = (float)idx;
+                                    atTargets.Add(idx, att);
+                                }
+                            }
+                        }
+                    }
+                    if (atTargets.Count > 0)
+                    {
+                        uint[] localids = new uint[0];
+                        lock (m_parts)
+                        {
+                            localids = new uint[m_parts.Count];
+                            int cntr = 0;
+                            foreach (SceneObjectPart part in m_parts.Values)
+                            {
+                                localids[cntr] = part.LocalId;
+                                cntr++;
+                            }
+                        }
+                        for (int ctr = 0; ctr < localids.Length; ctr++)
+                        {
+                            foreach (uint target in atTargets.Keys)
+                            {
+                                scriptPosTarget att = atTargets[target];
+                                // Reusing att.tolerance to hold the index of the target in the targets dictionary
+                                // to avoid deadlocking the sim.
+                                m_scene.TriggerAtTargetEvent(localids[ctr], (uint)att.tolerance, att.targetPos, m_rootPart.GroupPosition);
+
+
+                            }
+                        }
+                        return;
+                    }
+                    if (m_scriptListens_notAtTarget && !at_target)
+                    {
+                        //trigger not_at_target
+                        uint[] localids = new uint[0];
+                        lock (m_parts)
+                        {
+                            localids = new uint[m_parts.Count];
+                            int cntr = 0;
+                            foreach (SceneObjectPart part in m_parts.Values)
+                            {
+                                localids[cntr] = part.LocalId;
+                                cntr++;
+                            }
+                        }
+                        for (int ctr = 0; ctr < localids.Length; ctr++)
+                        {
+                            m_scene.TriggerNotAtTargetEvent(localids[ctr]);
+                        }
+                    }
+                }
+            }
+        }
+        
+        public float GetMass()
+        {
+            float retmass = 0f;
+            lock (m_parts)
+            {
+                foreach (SceneObjectPart part in m_parts.Values)
+                {
+                    retmass += part.GetMass();
+                }
+            }
+            return retmass;
+        }
+        
+        public void CheckSculptAndLoad()
+        {
+            lock (m_parts)
+            {
+                if (!IsDeleted)
+                {
+                    if ((RootPart.GetEffectiveObjectFlags() & (uint)PrimFlags.Phantom) == 0)
+                    {
+                        foreach (SceneObjectPart part in m_parts.Values)
+                        {
+                            if (part.Shape.SculptEntry && part.Shape.SculptTexture != UUID.Zero)
+                            {
+                                m_scene.AssetCache.GetAsset(part.Shape.SculptTexture, part.SculptTextureCallback, true);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        /// <summary>
+        /// Set the user group to which this scene object belongs.
+        /// </summary>
+        /// <param name="GroupID"></param>
+        /// <param name="client"></param>
+        public void SetGroup(UUID GroupID, IClientAPI client)
+        {
+            lock (m_parts)
+            {
+                foreach (SceneObjectPart part in m_parts.Values)
+                {
+                    part.SetGroup(GroupID, client);
+                    part.Inventory.ChangeInventoryGroup(GroupID);
+                }
+
+                HasGroupChanged = true;
+            }
+
+            ScheduleGroupForFullUpdate();
+        }
+
+        public void TriggerScriptChangedEvent(Changed val)
+        {
+            foreach (SceneObjectPart part in Children.Values)
+            {
+                part.TriggerScriptChangedEvent(val);
+            }
+        }
+        
+        public override string ToString()
+        {
+            return String.Format("{0} {1} ({2})", Name, UUID, AbsolutePosition);
+        }
+
+        public void SetAttachmentPoint(byte point)
+        {
+            lock (m_parts)
+            {
+                foreach (SceneObjectPart part in m_parts.Values)
+                    part.SetAttachmentPoint(point);
+            }
+        }
+    }
+}