Merge branch 'master' of git://opensimulator.org/git/opensim

3 files changed, 1431 insertions, 193 deletions

diff --git a/OpenSim/Region/Framework/Scenes/SceneObjectPart.cs b/OpenSim/Region/Framework/Scenes/SceneObjectPart.cs
index 39b109b..7a6449d 100644
--- a/OpenSim/Region/Framework/Scenes/SceneObjectPart.cs
+++ b/OpenSim/Region/Framework/Scenes/SceneObjectPart.cs
@@ -39,6 +39,7 @@ using OpenMetaverse.Packets;
 using OpenSim.Framework;
 using OpenSim.Region.Framework.Interfaces;
 using OpenSim.Region.Framework.Scenes.Scripting;
+using OpenSim.Region.Framework.Scenes.Serialization;
 using OpenSim.Region.Physics.Manager;
 
 namespace OpenSim.Region.Framework.Scenes
@@ -118,40 +119,36 @@ namespace OpenSim.Region.Framework.Scenes
         /// <value>
         /// Is this sop a root part?
         /// </value>
-        [XmlIgnore]
+        
         public bool IsRoot 
         {
            get { return ParentGroup.RootPart == this; } 
         }
 
-        // use only one serializer to give the runtime a chance to optimize it (it won't do that if you
-        // use a new instance every time)
-        private static XmlSerializer serializer = new XmlSerializer(typeof (SceneObjectPart));
-
         #region Fields
 
         public bool AllowedDrop;
 
-        [XmlIgnore]
+        
         public bool DIE_AT_EDGE;
 
-        [XmlIgnore]
+        
         public bool RETURN_AT_EDGE;
 
-        [XmlIgnore]
+        
         public bool BlockGrab;
 
-        [XmlIgnore]
+        
         public bool StatusSandbox;
 
-        [XmlIgnore]
+        
         public Vector3 StatusSandboxPos;
 
         // TODO: This needs to be persisted in next XML version update!
-        [XmlIgnore]
+        
         public readonly int[] PayPrice = {-2,-2,-2,-2,-2};
         
-        [XmlIgnore]
+        
         public PhysicsActor PhysActor
         {
             get { return m_physActor; }
@@ -166,43 +163,43 @@ namespace OpenSim.Region.Framework.Scenes
         //  Note: This isn't persisted in the database right now, as the fields for that aren't just there yet.
         //        Not a big problem as long as the script that sets it remains in the prim on startup.
         //        for SL compatibility it should be persisted though (set sound / displaytext / particlesystem, kill script)
-        [XmlIgnore]
+        
         public UUID Sound;
         
-        [XmlIgnore]
+        
         public byte SoundFlags;
         
-        [XmlIgnore]
+        
         public double SoundGain;
         
-        [XmlIgnore]
+        
         public double SoundRadius;
         
-        [XmlIgnore]
+        
         public uint TimeStampFull;
         
-        [XmlIgnore]
+        
         public uint TimeStampLastActivity; // Will be used for AutoReturn
         
-        [XmlIgnore]
+        
         public uint TimeStampTerse;
 
-        [XmlIgnore]
+        
         public UUID FromItemID;
 
-        [XmlIgnore]
+        
         public UUID FromFolderID;
 
-        [XmlIgnore]
+        
         public int STATUS_ROTATE_X;
 
-        [XmlIgnore]
+        
         public int STATUS_ROTATE_Y;
 
-        [XmlIgnore]
+        
         public int STATUS_ROTATE_Z;
         
-        [XmlIgnore]
+        
         private Dictionary<int, string> m_CollisionFilter = new Dictionary<int, string>();
                
         /// <value>
@@ -211,68 +208,68 @@ namespace OpenSim.Region.Framework.Scenes
         /// </value>
         private UUID m_fromUserInventoryItemID;
         
-        [XmlIgnore]
+        
         public UUID FromUserInventoryItemID
         {
             get { return m_fromUserInventoryItemID; }
         }
 
-        [XmlIgnore]
+        
         public bool IsAttachment;
 
-        [XmlIgnore]
+        
         public scriptEvents AggregateScriptEvents;
 
-        [XmlIgnore]
+        
         public UUID AttachedAvatar;
 
-        [XmlIgnore]
+        
         public Vector3 AttachedPos;
 
-        [XmlIgnore]
+        
         public uint AttachmentPoint;
 
-        [XmlIgnore]
+        
         public Vector3 RotationAxis = Vector3.One;
 
-        [XmlIgnore]
+        
         public bool VolumeDetectActive; // XmlIgnore set to avoid problems with persistance until I come to care for this
                                         // Certainly this must be a persistant setting finally
 
-        [XmlIgnore]
+        
         public bool IsWaitingForFirstSpinUpdatePacket;
 
-        [XmlIgnore]
+        
         public Quaternion SpinOldOrientation = Quaternion.Identity;
 
-        [XmlIgnore]
+        
         public Quaternion m_APIDTarget = Quaternion.Identity;
 
-        [XmlIgnore]
+        
         public float m_APIDDamp = 0;
 
-        [XmlIgnore]
+        
         public float m_APIDStrength = 0;
 
         /// <summary>
         /// This part's inventory
         /// </summary>
-        [XmlIgnore]
+        
         public IEntityInventory Inventory
         {
             get { return m_inventory; }
         }
         protected SceneObjectPartInventory m_inventory;
 
-        [XmlIgnore]
+        
         public bool Undoing;
 
-        [XmlIgnore]
+        
         public bool IgnoreUndoUpdate = false;
 
-        [XmlIgnore]
+        
         private PrimFlags LocalFlags;
-        [XmlIgnore]
+        
         private float m_damage = -1.0f;
         private byte[] m_TextureAnimation;
         private byte m_clickAction;
@@ -280,9 +277,9 @@ namespace OpenSim.Region.Framework.Scenes
         private string m_description = String.Empty;
         private readonly List<uint> m_lastColliders = new List<uint>();
         private int m_linkNum;
-        [XmlIgnore]
+        
         private int m_scriptAccessPin;
-        [XmlIgnore]
+        
         private readonly Dictionary<UUID, scriptEvents> m_scriptEvents = new Dictionary<UUID, scriptEvents>();
         private string m_sitName = String.Empty;
         private Quaternion m_sitTargetOrientation = Quaternion.Identity;
@@ -548,7 +545,7 @@ namespace OpenSim.Region.Framework.Scenes
         }
 
         
-        [XmlIgnore]
+        
         public Dictionary<int, string> CollisionFilter
         {
             get { return m_CollisionFilter; }
@@ -558,21 +555,21 @@ namespace OpenSim.Region.Framework.Scenes
             }
         }
 
-        [XmlIgnore]
+        
         public Quaternion APIDTarget
         {
             get { return m_APIDTarget; }
             set { m_APIDTarget = value; }
         }
 
-        [XmlIgnore]
+        
         public float APIDDamp
         {
             get { return m_APIDDamp; }
             set { m_APIDDamp = value; }
         }
 
-        [XmlIgnore]
+        
         public float APIDStrength
         {
             get { return m_APIDStrength; }
@@ -618,35 +615,35 @@ namespace OpenSim.Region.Framework.Scenes
             set { m_LoopSoundSlavePrims = value; }
         }
 
-        [XmlIgnore]
+        
         public Byte[] TextureAnimation
         {
             get { return m_TextureAnimation; }
             set { m_TextureAnimation = value; }
         }
 
-        [XmlIgnore]
+        
         public Byte[] ParticleSystem
         {
             get { return m_particleSystem; }
             set { m_particleSystem = value; }
         }
 
-        [XmlIgnore]
+        
         public DateTime Expires
         {
             get { return m_expires; }
             set { m_expires = value; }
         }
 
-        [XmlIgnore]
+        
         public DateTime Rezzed
         {
             get { return m_rezzed; }
             set { m_rezzed = value; }
         }
 
-        [XmlIgnore]
+        
         public float Damage
         {
             get { return m_damage; }
@@ -1019,7 +1016,7 @@ namespace OpenSim.Region.Framework.Scenes
             }
         }
 
-        [XmlIgnore]
+        
         public bool CreateSelected
         {
             get { return m_createSelected; }
@@ -1201,14 +1198,14 @@ namespace OpenSim.Region.Framework.Scenes
             }
         }
 
-        [XmlIgnore]
+        
         public UUID SitTargetAvatar
         {
             get { return m_sitTargetAvatar; }
             set { m_sitTargetAvatar = value; }
         }
 
-        [XmlIgnore]
+        
         public virtual UUID RegionID
         {
             get
@@ -1222,7 +1219,7 @@ namespace OpenSim.Region.Framework.Scenes
         }
 
         private UUID _parentUUID = UUID.Zero;
-        [XmlIgnore]
+        
         public UUID ParentUUID
         {
             get
@@ -1236,7 +1233,7 @@ namespace OpenSim.Region.Framework.Scenes
             set { _parentUUID = value; }
         }
 
-        [XmlIgnore]
+        
         public string SitAnimation
         {
             get { return m_sitAnimation; }
@@ -1850,7 +1847,7 @@ namespace OpenSim.Region.Framework.Scenes
         /// </summary>
         /// <param name="xmlReader"></param>
         /// <returns></returns>
-        public static SceneObjectPart FromXml(XmlReader xmlReader)
+        public static SceneObjectPart FromXml(XmlTextReader xmlReader)
         {
             return FromXml(UUID.Zero, xmlReader);
         }
@@ -1861,9 +1858,9 @@ namespace OpenSim.Region.Framework.Scenes
         /// <param name="fromUserInventoryItemId">The inventory id from which this part came, if applicable</param>
         /// <param name="xmlReader"></param>
         /// <returns></returns>
-        public static SceneObjectPart FromXml(UUID fromUserInventoryItemId, XmlReader xmlReader)
+        public static SceneObjectPart FromXml(UUID fromUserInventoryItemId, XmlTextReader xmlReader)
         {
-            SceneObjectPart part = (SceneObjectPart)serializer.Deserialize(xmlReader);
+            SceneObjectPart part = SceneObjectSerializer.Xml2ToSOP(xmlReader);
             part.m_fromUserInventoryItemID = fromUserInventoryItemId;
 
             // for tempOnRez objects, we have to fix the Expire date.
@@ -4058,9 +4055,9 @@ namespace OpenSim.Region.Framework.Scenes
         /// Serialize this part to xml.
         /// </summary>
         /// <param name="xmlWriter"></param>
-        public void ToXml(XmlWriter xmlWriter)
+        public void ToXml(XmlTextWriter xmlWriter)
         {
-            serializer.Serialize(xmlWriter, this);
+            SceneObjectSerializer.SOPToXml2(xmlWriter, this, new Dictionary<string, object>());
         }
 
         public void TriggerScriptChangedEvent(Changed val)
diff --git a/OpenSim/Region/Framework/Scenes/Serialization/SceneObjectSerializer.cs b/OpenSim/Region/Framework/Scenes/Serialization/SceneObjectSerializer.cs
index f5f6b90..252304b 100644
--- a/OpenSim/Region/Framework/Scenes/Serialization/SceneObjectSerializer.cs
+++ b/OpenSim/Region/Framework/Scenes/Serialization/SceneObjectSerializer.cs
@@ -26,6 +26,8 @@
  */
 
 using System;
+using System.Collections.Generic;
+using System.Drawing;
 using System.IO;
 using System.Reflection;
 using System.Xml;
@@ -65,14 +67,6 @@ namespace OpenSim.Region.Framework.Scenes.Serialization
             //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>");
-
             try
             {
                 StringReader  sr;
@@ -124,6 +118,7 @@ namespace OpenSim.Region.Framework.Scenes.Serialization
             }
         }
 
+
         /// <summary>
         /// Serialize a scene object to the original xml format
         /// </summary>
@@ -154,7 +149,7 @@ namespace OpenSim.Region.Framework.Scenes.Serialization
 
             writer.WriteStartElement(String.Empty, "SceneObjectGroup", String.Empty);
             writer.WriteStartElement(String.Empty, "RootPart", String.Empty);
-            ToOriginalXmlFormat(sceneObject.RootPart, writer);
+            ToXmlFormat(sceneObject.RootPart, writer);
             writer.WriteEndElement();
             writer.WriteStartElement(String.Empty, "OtherParts", String.Empty);
 
@@ -165,7 +160,7 @@ namespace OpenSim.Region.Framework.Scenes.Serialization
                 if (part.UUID != sceneObject.RootPart.UUID)
                 {
                     writer.WriteStartElement(String.Empty, "Part", String.Empty);
-                    ToOriginalXmlFormat(part, writer);
+                    ToXmlFormat(part, writer);
                     writer.WriteEndElement();
                 }
             }
@@ -177,9 +172,9 @@ namespace OpenSim.Region.Framework.Scenes.Serialization
             //m_log.DebugFormat("[SERIALIZER]: Finished serialization of SOG {0}, {1}ms", Name, System.Environment.TickCount - time);
         }
 
-        protected static void ToOriginalXmlFormat(SceneObjectPart part, XmlTextWriter writer)
+        protected static void ToXmlFormat(SceneObjectPart part, XmlTextWriter writer)
         {
-            part.ToXml(writer);
+            SOPToXml2(writer, part, new Dictionary<string, object>());
         }
         
         public static SceneObjectGroup FromXml2Format(string xmlData)
@@ -187,14 +182,6 @@ namespace OpenSim.Region.Framework.Scenes.Serialization
             //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>");
-
             try
             {
                 XmlDocument doc = new XmlDocument();
@@ -259,40 +246,1237 @@ namespace OpenSim.Region.Framework.Scenes.Serialization
             {
                 using (XmlTextWriter writer = new XmlTextWriter(sw))
                 {
-                    ToXml2Format(sceneObject, writer);
+                    SOGToXml2(writer, sceneObject, new Dictionary<string,object>());
                 }
 
                 return sw.ToString();
             }
         }
 
-        /// <summary>
-        /// Serialize a scene object to the 'xml2' format.
-        /// </summary>
-        /// <param name="sceneObject"></param>
-        /// <returns></returns>
-        public static void ToXml2Format(SceneObjectGroup sceneObject, XmlTextWriter writer)
+
+        #region manual serialization
+
+        private delegate void SOPXmlProcessor(SceneObjectPart sop, XmlTextReader reader);
+        private static Dictionary<string, SOPXmlProcessor> m_SOPXmlProcessors = new Dictionary<string, SOPXmlProcessor>();
+
+        private delegate void TaskInventoryXmlProcessor(TaskInventoryItem item, XmlTextReader reader);
+        private static Dictionary<string, TaskInventoryXmlProcessor> m_TaskInventoryXmlProcessors = new Dictionary<string, TaskInventoryXmlProcessor>();
+
+        private delegate void ShapeXmlProcessor(PrimitiveBaseShape shape, XmlTextReader reader);
+        private static Dictionary<string, ShapeXmlProcessor> m_ShapeXmlProcessors = new Dictionary<string, ShapeXmlProcessor>();
+
+        static SceneObjectSerializer()
         {
-            //m_log.DebugFormat("[SERIALIZER]: Starting serialization of SOG {0} to XML2", Name);
-            //int time = System.Environment.TickCount;
+            #region SOPXmlProcessors initialization
+            m_SOPXmlProcessors.Add("AllowedDrop", ProcessAllowedDrop);
+            m_SOPXmlProcessors.Add("CreatorID", ProcessCreatorID);
+            m_SOPXmlProcessors.Add("FolderID", ProcessFolderID);
+            m_SOPXmlProcessors.Add("InventorySerial", ProcessInventorySerial);
+            m_SOPXmlProcessors.Add("TaskInventory", ProcessTaskInventory);
+            m_SOPXmlProcessors.Add("UUID", ProcessUUID);
+            m_SOPXmlProcessors.Add("LocalId", ProcessLocalId);
+            m_SOPXmlProcessors.Add("Name", ProcessName);
+            m_SOPXmlProcessors.Add("Material", ProcessMaterial);
+            m_SOPXmlProcessors.Add("PassTouches", ProcessPassTouches);
+            m_SOPXmlProcessors.Add("RegionHandle", ProcessRegionHandle);
+            m_SOPXmlProcessors.Add("ScriptAccessPin", ProcessScriptAccessPin);
+            m_SOPXmlProcessors.Add("GroupPosition", ProcessGroupPosition);
+            m_SOPXmlProcessors.Add("OffsetPosition", ProcessOffsetPosition);
+            m_SOPXmlProcessors.Add("RotationOffset", ProcessRotationOffset);
+            m_SOPXmlProcessors.Add("Velocity", ProcessVelocity);
+            m_SOPXmlProcessors.Add("AngularVelocity", ProcessAngularVelocity);
+            m_SOPXmlProcessors.Add("Acceleration", ProcessAcceleration);
+            m_SOPXmlProcessors.Add("Description", ProcessDescription);
+            m_SOPXmlProcessors.Add("Color", ProcessColor);
+            m_SOPXmlProcessors.Add("Text", ProcessText);
+            m_SOPXmlProcessors.Add("SitName", ProcessSitName);
+            m_SOPXmlProcessors.Add("TouchName", ProcessTouchName);
+            m_SOPXmlProcessors.Add("LinkNum", ProcessLinkNum);
+            m_SOPXmlProcessors.Add("ClickAction", ProcessClickAction);
+            m_SOPXmlProcessors.Add("Shape", ProcessShape);
+            m_SOPXmlProcessors.Add("Scale", ProcessScale);
+            m_SOPXmlProcessors.Add("UpdateFlag", ProcessUpdateFlag);
+            m_SOPXmlProcessors.Add("SitTargetOrientation", ProcessSitTargetOrientation);
+            m_SOPXmlProcessors.Add("SitTargetPosition", ProcessSitTargetPosition);
+            m_SOPXmlProcessors.Add("SitTargetPositionLL", ProcessSitTargetPositionLL);
+            m_SOPXmlProcessors.Add("SitTargetOrientationLL", ProcessSitTargetOrientationLL);
+            m_SOPXmlProcessors.Add("ParentID", ProcessParentID);
+            m_SOPXmlProcessors.Add("CreationDate", ProcessCreationDate);
+            m_SOPXmlProcessors.Add("Category", ProcessCategory);
+            m_SOPXmlProcessors.Add("SalePrice", ProcessSalePrice);
+            m_SOPXmlProcessors.Add("ObjectSaleType", ProcessObjectSaleType);
+            m_SOPXmlProcessors.Add("OwnershipCost", ProcessOwnershipCost);
+            m_SOPXmlProcessors.Add("GroupID", ProcessGroupID);
+            m_SOPXmlProcessors.Add("OwnerID", ProcessOwnerID);
+            m_SOPXmlProcessors.Add("LastOwnerID", ProcessLastOwnerID);
+            m_SOPXmlProcessors.Add("BaseMask", ProcessBaseMask);
+            m_SOPXmlProcessors.Add("OwnerMask", ProcessOwnerMask);
+            m_SOPXmlProcessors.Add("GroupMask", ProcessGroupMask);
+            m_SOPXmlProcessors.Add("EveryoneMask", ProcessEveryoneMask);
+            m_SOPXmlProcessors.Add("NextOwnerMask", ProcessNextOwnerMask);
+            m_SOPXmlProcessors.Add("Flags", ProcessFlags);
+            m_SOPXmlProcessors.Add("CollisionSound", ProcessCollisionSound);
+            m_SOPXmlProcessors.Add("CollisionSoundVolume", ProcessCollisionSoundVolume);
+            m_SOPXmlProcessors.Add("MediaUrl", ProcessMediaUrl);
+            #endregion
+
+            #region TaskInventoryXmlProcessors initialization
+            m_TaskInventoryXmlProcessors.Add("AssetID", ProcessTIAssetID);
+            m_TaskInventoryXmlProcessors.Add("BasePermissions", ProcessTIBasePermissions);
+            m_TaskInventoryXmlProcessors.Add("CreationDate", ProcessTICreationDate);
+            m_TaskInventoryXmlProcessors.Add("CreatorID", ProcessTICreatorID);
+            m_TaskInventoryXmlProcessors.Add("Description", ProcessTIDescription);
+            m_TaskInventoryXmlProcessors.Add("EveryonePermissions", ProcessTIEveryonePermissions);
+            m_TaskInventoryXmlProcessors.Add("Flags", ProcessTIFlags);
+            m_TaskInventoryXmlProcessors.Add("GroupID", ProcessTIGroupID);
+            m_TaskInventoryXmlProcessors.Add("GroupPermissions", ProcessTIGroupPermissions);
+            m_TaskInventoryXmlProcessors.Add("InvType", ProcessTIInvType);
+            m_TaskInventoryXmlProcessors.Add("ItemID", ProcessTIItemID);
+            m_TaskInventoryXmlProcessors.Add("OldItemID", ProcessTIOldItemID);
+            m_TaskInventoryXmlProcessors.Add("LastOwnerID", ProcessTILastOwnerID);
+            m_TaskInventoryXmlProcessors.Add("Name", ProcessTIName);
+            m_TaskInventoryXmlProcessors.Add("NextPermissions", ProcessTINextPermissions);
+            m_TaskInventoryXmlProcessors.Add("OwnerID", ProcessTIOwnerID);
+            m_TaskInventoryXmlProcessors.Add("CurrentPermissions", ProcessTICurrentPermissions);
+            m_TaskInventoryXmlProcessors.Add("ParentID", ProcessTIParentID);
+            m_TaskInventoryXmlProcessors.Add("ParentPartID", ProcessTIParentPartID);
+            m_TaskInventoryXmlProcessors.Add("PermsGranter", ProcessTIPermsGranter);
+            m_TaskInventoryXmlProcessors.Add("PermsMask", ProcessTIPermsMask);
+            m_TaskInventoryXmlProcessors.Add("Type", ProcessTIType);
+            m_TaskInventoryXmlProcessors.Add("OwnerChanged", ProcessTIOwnerChanged);
+            
+            #endregion
+
+            #region ShapeXmlProcessors initialization
+            m_ShapeXmlProcessors.Add("ProfileCurve", ProcessShpProfileCurve);
+            m_ShapeXmlProcessors.Add("TextureEntry", ProcessShpTextureEntry);
+            m_ShapeXmlProcessors.Add("ExtraParams", ProcessShpExtraParams);
+            m_ShapeXmlProcessors.Add("PathBegin", ProcessShpPathBegin);
+            m_ShapeXmlProcessors.Add("PathCurve", ProcessShpPathCurve);
+            m_ShapeXmlProcessors.Add("PathEnd", ProcessShpPathEnd);
+            m_ShapeXmlProcessors.Add("PathRadiusOffset", ProcessShpPathRadiusOffset);
+            m_ShapeXmlProcessors.Add("PathRevolutions", ProcessShpPathRevolutions);
+            m_ShapeXmlProcessors.Add("PathScaleX", ProcessShpPathScaleX);
+            m_ShapeXmlProcessors.Add("PathScaleY", ProcessShpPathScaleY);
+            m_ShapeXmlProcessors.Add("PathShearX", ProcessShpPathShearX);
+            m_ShapeXmlProcessors.Add("PathShearY", ProcessShpPathShearY);
+            m_ShapeXmlProcessors.Add("PathSkew", ProcessShpPathSkew);
+            m_ShapeXmlProcessors.Add("PathTaperX", ProcessShpPathTaperX);
+            m_ShapeXmlProcessors.Add("PathTaperY", ProcessShpPathTaperY);
+            m_ShapeXmlProcessors.Add("PathTwist", ProcessShpPathTwist);
+            m_ShapeXmlProcessors.Add("PathTwistBegin", ProcessShpPathTwistBegin);
+            m_ShapeXmlProcessors.Add("PCode", ProcessShpPCode);
+            m_ShapeXmlProcessors.Add("ProfileBegin", ProcessShpProfileBegin);
+            m_ShapeXmlProcessors.Add("ProfileEnd", ProcessShpProfileEnd);
+            m_ShapeXmlProcessors.Add("ProfileHollow", ProcessShpProfileHollow);
+            m_ShapeXmlProcessors.Add("Scale", ProcessShpScale);
+            m_ShapeXmlProcessors.Add("State", ProcessShpState);
+            m_ShapeXmlProcessors.Add("ProfileShape", ProcessShpProfileShape);
+            m_ShapeXmlProcessors.Add("HollowShape", ProcessShpHollowShape);
+            m_ShapeXmlProcessors.Add("SculptTexture", ProcessShpSculptTexture);
+            m_ShapeXmlProcessors.Add("SculptType", ProcessShpSculptType);
+            m_ShapeXmlProcessors.Add("SculptData", ProcessShpSculptData);
+            m_ShapeXmlProcessors.Add("FlexiSoftness", ProcessShpFlexiSoftness);
+            m_ShapeXmlProcessors.Add("FlexiTension", ProcessShpFlexiTension);
+            m_ShapeXmlProcessors.Add("FlexiDrag", ProcessShpFlexiDrag);
+            m_ShapeXmlProcessors.Add("FlexiGravity", ProcessShpFlexiGravity);
+            m_ShapeXmlProcessors.Add("FlexiWind", ProcessShpFlexiWind);
+            m_ShapeXmlProcessors.Add("FlexiForceX", ProcessShpFlexiForceX);
+            m_ShapeXmlProcessors.Add("FlexiForceY", ProcessShpFlexiForceY);
+            m_ShapeXmlProcessors.Add("FlexiForceZ", ProcessShpFlexiForceZ);
+            m_ShapeXmlProcessors.Add("LightColorR", ProcessShpLightColorR);
+            m_ShapeXmlProcessors.Add("LightColorG", ProcessShpLightColorG);
+            m_ShapeXmlProcessors.Add("LightColorB", ProcessShpLightColorB);
+            m_ShapeXmlProcessors.Add("LightColorA", ProcessShpLightColorA);
+            m_ShapeXmlProcessors.Add("LightRadius", ProcessShpLightRadius);
+            m_ShapeXmlProcessors.Add("LightCutoff", ProcessShpLightCutoff);
+            m_ShapeXmlProcessors.Add("LightFalloff", ProcessShpLightFalloff);
+            m_ShapeXmlProcessors.Add("LightIntensity", ProcessShpLightIntensity);
+            m_ShapeXmlProcessors.Add("FlexiEntry", ProcessShpFlexiEntry);
+            m_ShapeXmlProcessors.Add("LightEntry", ProcessShpLightEntry);
+            m_ShapeXmlProcessors.Add("SculptEntry", ProcessShpSculptEntry);
+            m_ShapeXmlProcessors.Add("Media", ProcessShpMedia);
+            #endregion
+        }
+
+        #region SOPXmlProcessors
+        private static void ProcessAllowedDrop(SceneObjectPart obj, XmlTextReader reader)
+        {
+            obj.AllowedDrop = reader.ReadElementContentAsBoolean("AllowedDrop", String.Empty);
+        }
+
+        private static void ProcessCreatorID(SceneObjectPart obj, XmlTextReader reader)
+        {
+            obj.CreatorID = ReadUUID(reader, "CreatorID");
+        }
+
+        private static void ProcessFolderID(SceneObjectPart obj, XmlTextReader reader)
+        {
+            obj.FolderID = ReadUUID(reader, "FolderID");
+        }
+
+        private static void ProcessInventorySerial(SceneObjectPart obj, XmlTextReader reader)
+        {
+            obj.InventorySerial = (uint)reader.ReadElementContentAsInt("InventorySerial", String.Empty);
+        }
+
+        private static void ProcessTaskInventory(SceneObjectPart obj, XmlTextReader reader)
+        {
+            obj.TaskInventory = ReadTaskInventory(reader, "TaskInventory");
+        }
+
+        private static void ProcessUUID(SceneObjectPart obj, XmlTextReader reader)
+        {
+            obj.UUID = ReadUUID(reader, "UUID");
+        }
+
+        private static void ProcessLocalId(SceneObjectPart obj, XmlTextReader reader)
+        {
+            obj.LocalId = (uint)reader.ReadElementContentAsLong("LocalId", String.Empty);
+        }
+
+        private static void ProcessName(SceneObjectPart obj, XmlTextReader reader)
+        {
+            obj.Name = reader.ReadElementString("Name");
+        }
+
+        private static void ProcessMaterial(SceneObjectPart obj, XmlTextReader reader)
+        {
+            obj.Material = (byte)reader.ReadElementContentAsInt("Material", String.Empty);
+        }
+
+        private static void ProcessPassTouches(SceneObjectPart obj, XmlTextReader reader)
+        {
+            obj.PassTouches = reader.ReadElementContentAsBoolean("PassTouches", String.Empty);
+        }
+
+        private static void ProcessRegionHandle(SceneObjectPart obj, XmlTextReader reader)
+        {
+            obj.RegionHandle = (ulong)reader.ReadElementContentAsLong("RegionHandle", String.Empty);
+        }
+
+        private static void ProcessScriptAccessPin(SceneObjectPart obj, XmlTextReader reader)
+        {
+            obj.ScriptAccessPin = reader.ReadElementContentAsInt("ScriptAccessPin", String.Empty);
+        }
+
+        private static void ProcessGroupPosition(SceneObjectPart obj, XmlTextReader reader)
+        {
+            obj.GroupPosition = ReadVector(reader, "GroupPosition");
+        }
+
+        private static void ProcessOffsetPosition(SceneObjectPart obj, XmlTextReader reader)
+        {
+            obj.OffsetPosition = ReadVector(reader, "OffsetPosition"); ;
+        }
+
+        private static void ProcessRotationOffset(SceneObjectPart obj, XmlTextReader reader)
+        {
+            obj.RotationOffset = ReadQuaternion(reader, "RotationOffset");
+        }
+
+        private static void ProcessVelocity(SceneObjectPart obj, XmlTextReader reader)
+        {
+            obj.Velocity = ReadVector(reader, "Velocity");
+        }
+
+        private static void ProcessAngularVelocity(SceneObjectPart obj, XmlTextReader reader)
+        {
+            obj.AngularVelocity = ReadVector(reader, "AngularVelocity");
+        }
+
+        private static void ProcessAcceleration(SceneObjectPart obj, XmlTextReader reader)
+        {
+            obj.Acceleration = ReadVector(reader, "Acceleration");
+        }
+
+        private static void ProcessDescription(SceneObjectPart obj, XmlTextReader reader)
+        {
+            obj.Description = reader.ReadElementString("Description");
+        }
+
+        private static void ProcessColor(SceneObjectPart obj, XmlTextReader reader)
+        {
+            reader.ReadStartElement("Color");
+            if (reader.Name == "R")
+            {
+                float r = reader.ReadElementContentAsFloat("R", String.Empty);
+                float g = reader.ReadElementContentAsFloat("G", String.Empty);
+                float b = reader.ReadElementContentAsFloat("B", String.Empty);
+                float a = reader.ReadElementContentAsFloat("A", String.Empty);
+                obj.Color = Color.FromArgb((int)a, (int)r, (int)g, (int)b);
+                reader.ReadEndElement();
+            }
+        }
+
+        private static void ProcessText(SceneObjectPart obj, XmlTextReader reader)
+        {
+            obj.Text = reader.ReadElementString("Text", String.Empty);
+        }
+
+        private static void ProcessSitName(SceneObjectPart obj, XmlTextReader reader)
+        {
+            obj.SitName = reader.ReadElementString("SitName", String.Empty);
+        }
+
+        private static void ProcessTouchName(SceneObjectPart obj, XmlTextReader reader)
+        {
+            obj.TouchName = reader.ReadElementString("TouchName", String.Empty);
+        }
+
+        private static void ProcessLinkNum(SceneObjectPart obj, XmlTextReader reader)
+        {
+            obj.LinkNum = reader.ReadElementContentAsInt("LinkNum", String.Empty);
+        }
+
+        private static void ProcessClickAction(SceneObjectPart obj, XmlTextReader reader)
+        {
+            obj.ClickAction = (byte)reader.ReadElementContentAsInt("ClickAction", String.Empty);
+        }
+
+        private static void ProcessShape(SceneObjectPart obj, XmlTextReader reader)
+        {
+            obj.Shape = ReadShape(reader, "Shape");
+        }
+
+        private static void ProcessScale(SceneObjectPart obj, XmlTextReader reader)
+        {
+            obj.Scale = ReadVector(reader, "Scale");
+        }
+
+        private static void ProcessUpdateFlag(SceneObjectPart obj, XmlTextReader reader)
+        {
+            obj.UpdateFlag = (byte)reader.ReadElementContentAsInt("UpdateFlag", String.Empty);
+        }
+
+        private static void ProcessSitTargetOrientation(SceneObjectPart obj, XmlTextReader reader)
+        {
+            obj.SitTargetOrientation = ReadQuaternion(reader, "SitTargetOrientation");
+        }
+
+        private static void ProcessSitTargetPosition(SceneObjectPart obj, XmlTextReader reader)
+        {
+            obj.SitTargetPosition = ReadVector(reader, "SitTargetPosition");
+        }
+
+        private static void ProcessSitTargetPositionLL(SceneObjectPart obj, XmlTextReader reader)
+        {
+            obj.SitTargetPositionLL = ReadVector(reader, "SitTargetPositionLL");
+        }
+
+        private static void ProcessSitTargetOrientationLL(SceneObjectPart obj, XmlTextReader reader)
+        {
+            obj.SitTargetOrientationLL = ReadQuaternion(reader, "SitTargetOrientationLL");
+        }
+
+        private static void ProcessParentID(SceneObjectPart obj, XmlTextReader reader)
+        {
+            string str = reader.ReadElementContentAsString("ParentID", String.Empty);
+            obj.ParentID = Convert.ToUInt32(str);
+        }
+
+        private static void ProcessCreationDate(SceneObjectPart obj, XmlTextReader reader)
+        {
+            obj.CreationDate = reader.ReadElementContentAsInt("CreationDate", String.Empty);
+        }
+
+        private static void ProcessCategory(SceneObjectPart obj, XmlTextReader reader)
+        {
+            obj.Category = (uint)reader.ReadElementContentAsInt("Category", String.Empty);
+        }
+
+        private static void ProcessSalePrice(SceneObjectPart obj, XmlTextReader reader)
+        {
+            obj.SalePrice = reader.ReadElementContentAsInt("SalePrice", String.Empty);
+        }
+
+        private static void ProcessObjectSaleType(SceneObjectPart obj, XmlTextReader reader)
+        {
+            obj.ObjectSaleType = (byte)reader.ReadElementContentAsInt("ObjectSaleType", String.Empty);
+        }
+
+        private static void ProcessOwnershipCost(SceneObjectPart obj, XmlTextReader reader)
+        {
+            obj.OwnershipCost = reader.ReadElementContentAsInt("OwnershipCost", String.Empty);
+        }
+
+        private static void ProcessGroupID(SceneObjectPart obj, XmlTextReader reader)
+        {
+            obj.GroupID = ReadUUID(reader, "GroupID");
+        }
+
+        private static void ProcessOwnerID(SceneObjectPart obj, XmlTextReader reader)
+        {
+            obj.OwnerID = ReadUUID(reader, "OwnerID");
+        }
+
+        private static void ProcessLastOwnerID(SceneObjectPart obj, XmlTextReader reader)
+        {
+            obj.LastOwnerID = ReadUUID(reader, "LastOwnerID");
+        }
+
+        private static void ProcessBaseMask(SceneObjectPart obj, XmlTextReader reader)
+        {
+            obj.BaseMask = (uint)reader.ReadElementContentAsInt("BaseMask", String.Empty);
+        }
+
+        private static void ProcessOwnerMask(SceneObjectPart obj, XmlTextReader reader)
+        {
+            obj.OwnerMask = (uint)reader.ReadElementContentAsInt("OwnerMask", String.Empty);
+        }
+
+        private static void ProcessGroupMask(SceneObjectPart obj, XmlTextReader reader)
+        {
+            obj.GroupMask = (uint)reader.ReadElementContentAsInt("GroupMask", String.Empty);
+        }
+
+        private static void ProcessEveryoneMask(SceneObjectPart obj, XmlTextReader reader)
+        {
+            obj.EveryoneMask = (uint)reader.ReadElementContentAsInt("EveryoneMask", String.Empty);
+        }
+
+        private static void ProcessNextOwnerMask(SceneObjectPart obj, XmlTextReader reader)
+        {
+            obj.NextOwnerMask = (uint)reader.ReadElementContentAsInt("NextOwnerMask", String.Empty);
+        }
+
+        private static void ProcessFlags(SceneObjectPart obj, XmlTextReader reader)
+        {
+            string value = reader.ReadElementContentAsString("Flags", String.Empty);
+            // !!!!! to deal with flags without commas
+            if (value.Contains(" ") && !value.Contains(","))
+                value = value.Replace(" ", ", ");
+            obj.Flags = (PrimFlags)Enum.Parse(typeof(PrimFlags), value);
+        }
+
+        private static void ProcessCollisionSound(SceneObjectPart obj, XmlTextReader reader)
+        {
+            obj.CollisionSound = ReadUUID(reader, "CollisionSound");
+        }
+
+        private static void ProcessCollisionSoundVolume(SceneObjectPart obj, XmlTextReader reader)
+        {
+            obj.CollisionSoundVolume = reader.ReadElementContentAsFloat("CollisionSoundVolume", String.Empty);
+        }
+
+        private static void ProcessMediaUrl(SceneObjectPart obj, XmlTextReader reader)
+        {
+            obj.MediaUrl = reader.ReadElementContentAsString("MediaUrl", String.Empty);
+        }
+        #endregion
+
+        #region TaskInventoryXmlProcessors
+        private static void ProcessTIAssetID(TaskInventoryItem item, XmlTextReader reader)
+        {
+            item.AssetID = ReadUUID(reader, "AssetID");
+        }
+
+        private static void ProcessTIBasePermissions(TaskInventoryItem item, XmlTextReader reader)
+        {
+            item.BasePermissions = (uint)reader.ReadElementContentAsInt("BasePermissions", String.Empty);
+        }
+
+        private static void ProcessTICreationDate(TaskInventoryItem item, XmlTextReader reader)
+        {
+            item.CreationDate = (uint)reader.ReadElementContentAsInt("CreationDate", String.Empty);
+        }
+
+        private static void ProcessTICreatorID(TaskInventoryItem item, XmlTextReader reader)
+        {
+            item.CreatorID = ReadUUID(reader, "CreatorID");
+        }
+
+        private static void ProcessTIDescription(TaskInventoryItem item, XmlTextReader reader)
+        {
+            item.Description = reader.ReadElementContentAsString("Description", String.Empty);
+        }
+
+        private static void ProcessTIEveryonePermissions(TaskInventoryItem item, XmlTextReader reader)
+        {
+            item.EveryonePermissions = (uint)reader.ReadElementContentAsInt("EveryonePermissions", String.Empty);
+        }
+
+        private static void ProcessTIFlags(TaskInventoryItem item, XmlTextReader reader)
+        {
+            item.Flags = (uint)reader.ReadElementContentAsInt("Flags", String.Empty);
+        }
+
+        private static void ProcessTIGroupID(TaskInventoryItem item, XmlTextReader reader)
+        {
+            item.GroupID = ReadUUID(reader, "GroupID");
+        }
+
+        private static void ProcessTIGroupPermissions(TaskInventoryItem item, XmlTextReader reader)
+        {
+            item.GroupPermissions = (uint)reader.ReadElementContentAsInt("GroupPermissions", String.Empty);
+        }
+
+        private static void ProcessTIInvType(TaskInventoryItem item, XmlTextReader reader)
+        {
+            item.InvType = reader.ReadElementContentAsInt("InvType", String.Empty);
+        }
+
+        private static void ProcessTIItemID(TaskInventoryItem item, XmlTextReader reader)
+        {
+            item.ItemID = ReadUUID(reader, "ItemID");
+        }
+
+        private static void ProcessTIOldItemID(TaskInventoryItem item, XmlTextReader reader)
+        {
+            item.OldItemID = ReadUUID(reader, "OldItemID");
+        }
+
+        private static void ProcessTILastOwnerID(TaskInventoryItem item, XmlTextReader reader)
+        {
+            item.LastOwnerID = ReadUUID(reader, "LastOwnerID");
+        }
+
+        private static void ProcessTIName(TaskInventoryItem item, XmlTextReader reader)
+        {
+            item.Name = reader.ReadElementContentAsString("Name", String.Empty);
+        }
+
+        private static void ProcessTINextPermissions(TaskInventoryItem item, XmlTextReader reader)
+        {
+            item.NextPermissions = (uint)reader.ReadElementContentAsInt("NextPermissions", String.Empty);
+        }
+
+        private static void ProcessTIOwnerID(TaskInventoryItem item, XmlTextReader reader)
+        {
+            item.OwnerID = ReadUUID(reader, "OwnerID");
+        }
+
+        private static void ProcessTICurrentPermissions(TaskInventoryItem item, XmlTextReader reader)
+        {
+            item.CurrentPermissions = (uint)reader.ReadElementContentAsInt("CurrentPermissions", String.Empty);
+        }
+
+        private static void ProcessTIParentID(TaskInventoryItem item, XmlTextReader reader)
+        {
+            item.ParentID = ReadUUID(reader, "ParentID");
+        }
+
+        private static void ProcessTIParentPartID(TaskInventoryItem item, XmlTextReader reader)
+        {
+            item.ParentPartID = ReadUUID(reader, "ParentPartID");
+        }
+
+        private static void ProcessTIPermsGranter(TaskInventoryItem item, XmlTextReader reader)
+        {
+            item.PermsGranter = ReadUUID(reader, "PermsGranter");
+        }
+
+        private static void ProcessTIPermsMask(TaskInventoryItem item, XmlTextReader reader)
+        {
+            item.PermsMask = reader.ReadElementContentAsInt("PermsMask", String.Empty);
+        }
+
+        private static void ProcessTIType(TaskInventoryItem item, XmlTextReader reader)
+        {
+            item.Type = reader.ReadElementContentAsInt("Type", String.Empty);
+        }
+
+        private static void ProcessTIOwnerChanged(TaskInventoryItem item, XmlTextReader reader)
+        {
+            item.OwnerChanged = reader.ReadElementContentAsBoolean("OwnerChanged", String.Empty);
+        }
+
+        #endregion
+
+        #region ShapeXmlProcessors
+        private static void ProcessShpProfileCurve(PrimitiveBaseShape shp, XmlTextReader reader)
+        {
+            shp.ProfileCurve = (byte)reader.ReadElementContentAsInt("ProfileCurve", String.Empty);
+        }
+
+        private static void ProcessShpTextureEntry(PrimitiveBaseShape shp, XmlTextReader reader)
+        {
+            byte[] teData = Convert.FromBase64String(reader.ReadElementString("TextureEntry"));
+            shp.Textures = new Primitive.TextureEntry(teData, 0, teData.Length);   
+        }
+
+        private static void ProcessShpExtraParams(PrimitiveBaseShape shp, XmlTextReader reader)
+        {
+            shp.ExtraParams = Convert.FromBase64String(reader.ReadElementString("ExtraParams"));
+        }
+
+        private static void ProcessShpPathBegin(PrimitiveBaseShape shp, XmlTextReader reader)
+        {
+            shp.PathBegin = (ushort)reader.ReadElementContentAsInt("PathBegin", String.Empty);
+        }
+
+        private static void ProcessShpPathCurve(PrimitiveBaseShape shp, XmlTextReader reader)
+        {
+            shp.PathCurve = (byte)reader.ReadElementContentAsInt("PathCurve", String.Empty);
+        }
+
+        private static void ProcessShpPathEnd(PrimitiveBaseShape shp, XmlTextReader reader)
+        {
+            shp.PathEnd = (ushort)reader.ReadElementContentAsInt("PathEnd", String.Empty);
+        }
 
+        private static void ProcessShpPathRadiusOffset(PrimitiveBaseShape shp, XmlTextReader reader)
+        {
+            shp.PathRadiusOffset = (sbyte)reader.ReadElementContentAsInt("PathRadiusOffset", String.Empty);
+        }
+
+        private static void ProcessShpPathRevolutions(PrimitiveBaseShape shp, XmlTextReader reader)
+        {
+            shp.PathRevolutions = (byte)reader.ReadElementContentAsInt("PathRevolutions", String.Empty);
+        }
+
+        private static void ProcessShpPathScaleX(PrimitiveBaseShape shp, XmlTextReader reader)
+        {
+            shp.PathScaleX = (byte)reader.ReadElementContentAsInt("PathScaleX", String.Empty);
+        }
+
+        private static void ProcessShpPathScaleY(PrimitiveBaseShape shp, XmlTextReader reader)
+        {
+            shp.PathScaleY = (byte)reader.ReadElementContentAsInt("PathScaleY", String.Empty);
+        }
+
+        private static void ProcessShpPathShearX(PrimitiveBaseShape shp, XmlTextReader reader)
+        {
+            shp.PathShearX = (byte)reader.ReadElementContentAsInt("PathShearX", String.Empty);
+        }
+
+        private static void ProcessShpPathShearY(PrimitiveBaseShape shp, XmlTextReader reader)
+        {
+            shp.PathShearY = (byte)reader.ReadElementContentAsInt("PathShearY", String.Empty);
+        }
+
+        private static void ProcessShpPathSkew(PrimitiveBaseShape shp, XmlTextReader reader)
+        {
+            shp.PathSkew = (sbyte)reader.ReadElementContentAsInt("PathSkew", String.Empty);
+        }
+
+        private static void ProcessShpPathTaperX(PrimitiveBaseShape shp, XmlTextReader reader)
+        {
+            shp.PathTaperX = (sbyte)reader.ReadElementContentAsInt("PathTaperX", String.Empty);
+        }
+
+        private static void ProcessShpPathTaperY(PrimitiveBaseShape shp, XmlTextReader reader)
+        {
+            shp.PathTaperY = (sbyte)reader.ReadElementContentAsInt("PathTaperY", String.Empty);
+        }
+
+        private static void ProcessShpPathTwist(PrimitiveBaseShape shp, XmlTextReader reader)
+        {
+            shp.PathTwist = (sbyte)reader.ReadElementContentAsInt("PathTwist", String.Empty);
+        }
+
+        private static void ProcessShpPathTwistBegin(PrimitiveBaseShape shp, XmlTextReader reader)
+        {
+            shp.PathTwistBegin = (sbyte)reader.ReadElementContentAsInt("PathTwistBegin", String.Empty);
+        }
+
+        private static void ProcessShpPCode(PrimitiveBaseShape shp, XmlTextReader reader)
+        {
+            shp.PCode = (byte)reader.ReadElementContentAsInt("PCode", String.Empty);
+        }
+
+        private static void ProcessShpProfileBegin(PrimitiveBaseShape shp, XmlTextReader reader)
+        {
+            shp.ProfileBegin = (ushort)reader.ReadElementContentAsInt("ProfileBegin", String.Empty);
+        }
+
+        private static void ProcessShpProfileEnd(PrimitiveBaseShape shp, XmlTextReader reader)
+        {
+            shp.ProfileEnd = (ushort)reader.ReadElementContentAsInt("ProfileEnd", String.Empty);
+        }
+
+        private static void ProcessShpProfileHollow(PrimitiveBaseShape shp, XmlTextReader reader)
+        {
+            shp.ProfileHollow = (ushort)reader.ReadElementContentAsInt("ProfileHollow", String.Empty);
+        }
+
+        private static void ProcessShpScale(PrimitiveBaseShape shp, XmlTextReader reader)
+        {
+            shp.Scale = ReadVector(reader, "Scale");
+        }
+
+        private static void ProcessShpState(PrimitiveBaseShape shp, XmlTextReader reader)
+        {
+            shp.State = (byte)reader.ReadElementContentAsInt("State", String.Empty);
+        }
+
+        private static void ProcessShpProfileShape(PrimitiveBaseShape shp, XmlTextReader reader)
+        {
+            string value = reader.ReadElementContentAsString("ProfileShape", String.Empty);
+            // !!!!! to deal with flags without commas
+            if (value.Contains(" ") && !value.Contains(","))
+                value = value.Replace(" ", ", ");
+            shp.ProfileShape = (ProfileShape)Enum.Parse(typeof(ProfileShape), value);
+        }
+
+        private static void ProcessShpHollowShape(PrimitiveBaseShape shp, XmlTextReader reader)
+        {
+            string value = reader.ReadElementContentAsString("HollowShape", String.Empty);
+            // !!!!! to deal with flags without commas
+            if (value.Contains(" ") && !value.Contains(","))
+                value = value.Replace(" ", ", ");
+            shp.HollowShape = (HollowShape)Enum.Parse(typeof(HollowShape), value);
+        }
+        
+        private static void ProcessShpSculptTexture(PrimitiveBaseShape shp, XmlTextReader reader)
+        {
+            shp.SculptTexture = ReadUUID(reader, "SculptTexture");
+        }
+
+        private static void ProcessShpSculptType(PrimitiveBaseShape shp, XmlTextReader reader)
+        {
+            shp.SculptType = (byte)reader.ReadElementContentAsInt("SculptType", String.Empty);
+        }
+
+        private static void ProcessShpSculptData(PrimitiveBaseShape shp, XmlTextReader reader)
+        {
+            shp.SculptData = Convert.FromBase64String(reader.ReadElementString("SculptData"));
+        }
+
+        private static void ProcessShpFlexiSoftness(PrimitiveBaseShape shp, XmlTextReader reader)
+        {
+            shp.FlexiSoftness = reader.ReadElementContentAsInt("FlexiSoftness", String.Empty);
+        }
+
+        private static void ProcessShpFlexiTension(PrimitiveBaseShape shp, XmlTextReader reader)
+        {
+            shp.FlexiTension = reader.ReadElementContentAsFloat("FlexiTension", String.Empty);
+        }
+
+        private static void ProcessShpFlexiDrag(PrimitiveBaseShape shp, XmlTextReader reader)
+        {
+            shp.FlexiDrag = reader.ReadElementContentAsFloat("FlexiDrag", String.Empty);
+        }
+
+        private static void ProcessShpFlexiGravity(PrimitiveBaseShape shp, XmlTextReader reader)
+        {
+            shp.FlexiGravity = reader.ReadElementContentAsFloat("FlexiGravity", String.Empty);
+        }
+
+        private static void ProcessShpFlexiWind(PrimitiveBaseShape shp, XmlTextReader reader)
+        {
+            shp.FlexiWind = reader.ReadElementContentAsFloat("FlexiWind", String.Empty);
+        }
+
+        private static void ProcessShpFlexiForceX(PrimitiveBaseShape shp, XmlTextReader reader)
+        {
+            shp.FlexiForceX = reader.ReadElementContentAsFloat("FlexiForceX", String.Empty);
+        }
+
+        private static void ProcessShpFlexiForceY(PrimitiveBaseShape shp, XmlTextReader reader)
+        {
+            shp.FlexiForceY = reader.ReadElementContentAsFloat("FlexiForceY", String.Empty);
+        }
+
+        private static void ProcessShpFlexiForceZ(PrimitiveBaseShape shp, XmlTextReader reader)
+        {
+            shp.FlexiForceZ = reader.ReadElementContentAsFloat("FlexiForceZ", String.Empty);
+        }
+
+        private static void ProcessShpLightColorR(PrimitiveBaseShape shp, XmlTextReader reader)
+        {
+            shp.LightColorR = reader.ReadElementContentAsFloat("LightColorR", String.Empty);
+        }
+
+        private static void ProcessShpLightColorG(PrimitiveBaseShape shp, XmlTextReader reader)
+        {
+            shp.LightColorG = reader.ReadElementContentAsFloat("LightColorG", String.Empty);
+        }
+
+        private static void ProcessShpLightColorB(PrimitiveBaseShape shp, XmlTextReader reader)
+        {
+            shp.LightColorB = reader.ReadElementContentAsFloat("LightColorB", String.Empty);
+        }
+
+        private static void ProcessShpLightColorA(PrimitiveBaseShape shp, XmlTextReader reader)
+        {
+            shp.LightColorA = reader.ReadElementContentAsFloat("LightColorA", String.Empty);
+        }
+
+        private static void ProcessShpLightRadius(PrimitiveBaseShape shp, XmlTextReader reader)
+        {
+            shp.LightRadius = reader.ReadElementContentAsFloat("LightRadius", String.Empty);
+        }
+
+        private static void ProcessShpLightCutoff(PrimitiveBaseShape shp, XmlTextReader reader)
+        {
+            shp.LightCutoff = reader.ReadElementContentAsFloat("LightCutoff", String.Empty);
+        }
+
+        private static void ProcessShpLightFalloff(PrimitiveBaseShape shp, XmlTextReader reader)
+        {
+            shp.LightFalloff = reader.ReadElementContentAsFloat("LightFalloff", String.Empty);
+        }
+
+        private static void ProcessShpLightIntensity(PrimitiveBaseShape shp, XmlTextReader reader)
+        {
+            shp.LightIntensity = reader.ReadElementContentAsFloat("LightIntensity", String.Empty);
+        }
+
+        private static void ProcessShpFlexiEntry(PrimitiveBaseShape shp, XmlTextReader reader)
+        {
+            shp.FlexiEntry = reader.ReadElementContentAsBoolean("FlexiEntry", String.Empty);
+        }
+
+        private static void ProcessShpLightEntry(PrimitiveBaseShape shp, XmlTextReader reader)
+        {
+            shp.LightEntry = reader.ReadElementContentAsBoolean("LightEntry", String.Empty);
+        }
+
+        private static void ProcessShpSculptEntry(PrimitiveBaseShape shp, XmlTextReader reader)
+        {
+            shp.SculptEntry = reader.ReadElementContentAsBoolean("SculptEntry", String.Empty);
+        }
+
+        private static void ProcessShpMedia(PrimitiveBaseShape shp, XmlTextReader reader)
+        {
+            string value = reader.ReadElementContentAsString("Media", String.Empty);
+            shp.Media = PrimitiveBaseShape.MediaList.FromXml(value);
+        }
+
+
+        #endregion
+
+        ////////// Write /////////
+
+        public static void SOGToXml2(XmlTextWriter writer, SceneObjectGroup sog, Dictionary<string, object>options)
+        {
             writer.WriteStartElement(String.Empty, "SceneObjectGroup", String.Empty);
-            sceneObject.RootPart.ToXml(writer);
+            SOPToXml2(writer, sog.RootPart, options);
             writer.WriteStartElement(String.Empty, "OtherParts", String.Empty);
 
-            SceneObjectPart[] parts = sceneObject.Parts;
-            for (int i = 0; i < parts.Length; i++)
+            sog.ForEachPart(delegate(SceneObjectPart sop)
             {
-                SceneObjectPart part = parts[i];
-                if (part.UUID != sceneObject.RootPart.UUID)
-                    part.ToXml(writer);
+                if (sop.UUID != sog.RootPart.UUID)
+                    SOPToXml2(writer, sop, options);
+            });
+
+            writer.WriteEndElement();
+            writer.WriteEndElement();
+        }
+
+        public static void SOPToXml2(XmlTextWriter writer, SceneObjectPart sop, Dictionary<string, object> options)
+        {
+            writer.WriteStartElement("SceneObjectPart");
+            writer.WriteAttributeString("xmlns:xsi", "http://www.w3.org/2001/XMLSchema-instance");
+            writer.WriteAttributeString("xmlns:xsd", "http://www.w3.org/2001/XMLSchema");
+
+            writer.WriteElementString("AllowedDrop", sop.AllowedDrop.ToString().ToLower());
+            WriteUUID(writer, "CreatorID", sop.CreatorID, options);
+            WriteUUID(writer, "FolderID", sop.FolderID, options);
+            writer.WriteElementString("InventorySerial", sop.InventorySerial.ToString());
+
+            WriteTaskInventory(writer, sop.TaskInventory, options);
+
+            WriteUUID(writer, "UUID", sop.UUID, options);
+            writer.WriteElementString("LocalId", sop.LocalId.ToString());
+            writer.WriteElementString("Name", sop.Name);
+            writer.WriteElementString("Material", sop.Material.ToString());
+            writer.WriteElementString("PassTouches", sop.PassTouches.ToString().ToLower());
+            writer.WriteElementString("RegionHandle", sop.RegionHandle.ToString());
+            writer.WriteElementString("ScriptAccessPin", sop.ScriptAccessPin.ToString());
+
+            WriteVector(writer, "GroupPosition", sop.GroupPosition);
+            WriteVector(writer, "OffsetPosition", sop.OffsetPosition);
+
+            WriteQuaternion(writer, "RotationOffset", sop.RotationOffset);
+            WriteVector(writer, "Velocity", sop.Velocity);
+            WriteVector(writer, "AngularVelocity", sop.AngularVelocity);
+            WriteVector(writer, "Acceleration", sop.Acceleration);
+            writer.WriteElementString("Description", sop.Description);
+            if (sop.Color != null)
+            {
+                writer.WriteStartElement("Color");
+                writer.WriteElementString("R", sop.Color.R.ToString(Utils.EnUsCulture));
+                writer.WriteElementString("G", sop.Color.G.ToString(Utils.EnUsCulture));
+                writer.WriteElementString("B", sop.Color.B.ToString(Utils.EnUsCulture));
+                writer.WriteElementString("A", sop.Color.G.ToString(Utils.EnUsCulture));
+                writer.WriteEndElement();
             }
 
-            writer.WriteEndElement(); // End of OtherParts
-            sceneObject.SaveScriptedState(writer);
-            writer.WriteEndElement(); // End of SceneObjectGroup
+            writer.WriteElementString("Text", sop.Text);
+            writer.WriteElementString("SitName", sop.SitName);
+            writer.WriteElementString("TouchName", sop.TouchName);
 
-            //m_log.DebugFormat("[SERIALIZER]: Finished serialization of SOG {0} to XML2, {1}ms", Name, System.Environment.TickCount - time);
+            writer.WriteElementString("LinkNum", sop.LinkNum.ToString());
+            writer.WriteElementString("ClickAction", sop.ClickAction.ToString());
+
+            WriteShape(writer, sop.Shape, options);
+
+            WriteVector(writer, "Scale", sop.Scale);
+            writer.WriteElementString("UpdateFlag", sop.UpdateFlag.ToString());
+            WriteQuaternion(writer, "SitTargetOrientation", sop.SitTargetOrientation); 
+            WriteVector(writer, "SitTargetPosition", sop.SitTargetPosition);
+            WriteVector(writer, "SitTargetPositionLL", sop.SitTargetPositionLL);
+            WriteQuaternion(writer, "SitTargetOrientationLL", sop.SitTargetOrientationLL);
+            writer.WriteElementString("ParentID", sop.ParentID.ToString());
+            writer.WriteElementString("CreationDate", sop.CreationDate.ToString());
+            writer.WriteElementString("Category", sop.Category.ToString());
+            writer.WriteElementString("SalePrice", sop.SalePrice.ToString());
+            writer.WriteElementString("ObjectSaleType", sop.ObjectSaleType.ToString());
+            writer.WriteElementString("OwnershipCost", sop.OwnershipCost.ToString());
+            WriteUUID(writer, "GroupID", sop.GroupID, options);
+            WriteUUID(writer, "OwnerID", sop.OwnerID, options);
+            WriteUUID(writer, "LastOwnerID", sop.LastOwnerID, options);
+            writer.WriteElementString("BaseMask", sop.BaseMask.ToString());
+            writer.WriteElementString("OwnerMask", sop.OwnerMask.ToString());
+            writer.WriteElementString("GroupMask", sop.GroupMask.ToString());
+            writer.WriteElementString("EveryoneMask", sop.EveryoneMask.ToString());
+            writer.WriteElementString("NextOwnerMask", sop.NextOwnerMask.ToString());
+            writer.WriteElementString("Flags", sop.Flags.ToString());
+            WriteUUID(writer, "CollisionSound", sop.CollisionSound, options);
+            writer.WriteElementString("CollisionSoundVolume", sop.CollisionSoundVolume.ToString());
+            if (sop.MediaUrl != null)
+                writer.WriteElementString("MediaUrl", sop.MediaUrl.ToString());
+
+            writer.WriteEndElement();
+        }
+
+        static void WriteUUID(XmlTextWriter writer, string name, UUID id, Dictionary<string, object> options)
+        {
+            writer.WriteStartElement(name);
+            if (options.ContainsKey("old-guids"))
+                writer.WriteElementString("Guid", id.ToString());
+            else
+                writer.WriteElementString("UUID", id.ToString());
+            writer.WriteEndElement();
+        }
+
+        static void WriteVector(XmlTextWriter writer, string name, Vector3 vec)
+        {
+            writer.WriteStartElement(name);
+            writer.WriteElementString("X", vec.X.ToString(Utils.EnUsCulture));
+            writer.WriteElementString("Y", vec.Y.ToString(Utils.EnUsCulture));
+            writer.WriteElementString("Z", vec.Z.ToString(Utils.EnUsCulture));
+            writer.WriteEndElement();
+        }
+
+        static void WriteQuaternion(XmlTextWriter writer, string name, Quaternion quat)
+        {
+            writer.WriteStartElement(name);
+            writer.WriteElementString("X", quat.X.ToString(Utils.EnUsCulture));
+            writer.WriteElementString("Y", quat.Y.ToString(Utils.EnUsCulture));
+            writer.WriteElementString("Z", quat.Z.ToString(Utils.EnUsCulture));
+            writer.WriteElementString("W", quat.W.ToString(Utils.EnUsCulture));
+            writer.WriteEndElement();
         }
+
+        static void WriteTaskInventory(XmlTextWriter writer, TaskInventoryDictionary tinv, Dictionary<string, object> options)
+        {
+            if (tinv.Count > 0) // otherwise skip this
+            {
+                writer.WriteStartElement("TaskInventory");
+
+                foreach (TaskInventoryItem item in tinv.Values)
+                {
+                    writer.WriteStartElement("TaskInventoryItem");
+
+                    WriteUUID(writer, "AssetID", item.AssetID, options);
+                    writer.WriteElementString("BasePermissions", item.BasePermissions.ToString());
+                    writer.WriteElementString("CreationDate", item.CreationDate.ToString());
+                    WriteUUID(writer, "CreatorID", item.CreatorID, options);
+                    writer.WriteElementString("Description", item.Description);
+                    writer.WriteElementString("EveryonePermissions", item.EveryonePermissions.ToString());
+                    writer.WriteElementString("Flags", item.Flags.ToString());
+                    WriteUUID(writer, "GroupID", item.GroupID, options);
+                    writer.WriteElementString("GroupPermissions", item.GroupPermissions.ToString());
+                    writer.WriteElementString("InvType", item.InvType.ToString());
+                    WriteUUID(writer, "ItemID", item.ItemID, options);
+                    WriteUUID(writer, "OldItemID", item.OldItemID, options);
+                    WriteUUID(writer, "LastOwnerID", item.LastOwnerID, options);
+                    writer.WriteElementString("Name", item.Name);
+                    writer.WriteElementString("NextPermissions", item.NextPermissions.ToString());
+                    WriteUUID(writer, "OwnerID", item.OwnerID, options);
+                    writer.WriteElementString("CurrentPermissions", item.CurrentPermissions.ToString());
+                    WriteUUID(writer, "ParentID", item.ParentID, options);
+                    WriteUUID(writer, "ParentPartID", item.ParentPartID, options);
+                    WriteUUID(writer, "PermsGranter", item.PermsGranter, options);
+                    writer.WriteElementString("PermsMask", item.PermsMask.ToString());
+                    writer.WriteElementString("Type", item.Type.ToString());
+                    writer.WriteElementString("OwnerChanged", item.OwnerChanged.ToString().ToLower());
+
+                    writer.WriteEndElement(); // TaskInventoryItem
+                }
+
+                writer.WriteEndElement(); // TaskInventory
+            }
+        }
+
+        static void WriteShape(XmlTextWriter writer, PrimitiveBaseShape shp, Dictionary<string, object> options)
+        {
+            if (shp != null)
+            {
+                writer.WriteStartElement("Shape");
+
+                writer.WriteElementString("ProfileCurve", shp.ProfileCurve.ToString());
+
+                writer.WriteStartElement("TextureEntry");
+                byte[] te;
+                if (shp.TextureEntry != null)
+                    te = shp.TextureEntry;
+                else
+                    te = Utils.EmptyBytes;
+                writer.WriteBase64(te, 0, te.Length);
+                writer.WriteEndElement(); // TextureEntry
+
+                writer.WriteStartElement("ExtraParams");
+                byte[] ep;
+                if (shp.ExtraParams != null)
+                    ep = shp.ExtraParams;
+                else
+                    ep = Utils.EmptyBytes;
+                writer.WriteBase64(ep, 0, ep.Length);
+                writer.WriteEndElement(); // ExtraParams
+
+                writer.WriteElementString("PathBegin", shp.PathBegin.ToString());
+                writer.WriteElementString("PathCurve", shp.PathCurve.ToString());
+                writer.WriteElementString("PathEnd", shp.PathEnd.ToString());
+                writer.WriteElementString("PathRadiusOffset", shp.PathRadiusOffset.ToString());
+                writer.WriteElementString("PathRevolutions", shp.PathRevolutions.ToString());
+                writer.WriteElementString("PathScaleX", shp.PathScaleX.ToString());
+                writer.WriteElementString("PathScaleY", shp.PathScaleY.ToString());
+                writer.WriteElementString("PathShearX", shp.PathShearX.ToString());
+                writer.WriteElementString("PathShearY", shp.PathShearY.ToString());
+                writer.WriteElementString("PathSkew", shp.PathSkew.ToString());
+                writer.WriteElementString("PathTaperX", shp.PathTaperX.ToString());
+                writer.WriteElementString("PathTaperY", shp.PathTaperY.ToString());
+                writer.WriteElementString("PathTwist", shp.PathTwist.ToString());
+                writer.WriteElementString("PathTwistBegin", shp.PathTwistBegin.ToString());
+                writer.WriteElementString("PCode", shp.PCode.ToString());
+                writer.WriteElementString("ProfileBegin", shp.ProfileBegin.ToString());
+                writer.WriteElementString("ProfileEnd", shp.ProfileEnd.ToString());
+                writer.WriteElementString("ProfileHollow", shp.ProfileHollow.ToString());
+                writer.WriteElementString("State", shp.State.ToString());
+
+                writer.WriteElementString("ProfileShape", shp.ProfileShape.ToString());
+                writer.WriteElementString("HollowShape", shp.HollowShape.ToString());
+
+                WriteUUID(writer, "SculptTexture", shp.SculptTexture, options);
+                writer.WriteElementString("SculptType", shp.SculptType.ToString());
+                writer.WriteStartElement("SculptData");
+                byte[] sd;
+                if (shp.SculptData != null)
+                    sd = shp.ExtraParams;
+                else
+                    sd = Utils.EmptyBytes;
+                writer.WriteBase64(sd, 0, sd.Length);
+                writer.WriteEndElement(); // SculptData
+
+                writer.WriteElementString("FlexiSoftness", shp.FlexiSoftness.ToString());
+                writer.WriteElementString("FlexiTension", shp.FlexiTension.ToString());
+                writer.WriteElementString("FlexiDrag", shp.FlexiDrag.ToString());
+                writer.WriteElementString("FlexiGravity", shp.FlexiGravity.ToString());
+                writer.WriteElementString("FlexiWind", shp.FlexiWind.ToString());
+                writer.WriteElementString("FlexiForceX", shp.FlexiForceX.ToString());
+                writer.WriteElementString("FlexiForceY", shp.FlexiForceY.ToString());
+                writer.WriteElementString("FlexiForceZ", shp.FlexiForceZ.ToString());
+
+                writer.WriteElementString("LightColorR", shp.LightColorR.ToString());
+                writer.WriteElementString("LightColorG", shp.LightColorG.ToString());
+                writer.WriteElementString("LightColorB", shp.LightColorB.ToString());
+                writer.WriteElementString("LightColorA", shp.LightColorA.ToString());
+                writer.WriteElementString("LightRadius", shp.LightRadius.ToString());
+                writer.WriteElementString("LightCutoff", shp.LightCutoff.ToString());
+                writer.WriteElementString("LightFalloff", shp.LightFalloff.ToString());
+                writer.WriteElementString("LightIntensity", shp.LightIntensity.ToString());
+
+                writer.WriteElementString("FlexiEntry", shp.FlexiEntry.ToString().ToLower());
+                writer.WriteElementString("LightEntry", shp.LightEntry.ToString().ToLower());
+                writer.WriteElementString("SculptEntry", shp.SculptEntry.ToString().ToLower());
+
+                if (shp.Media != null)
+                    writer.WriteElementString("Media", shp.Media.ToXml());
+
+                writer.WriteEndElement(); // Shape
+            }
+        }
+
+        //////// Read /////////
+        public static bool Xml2ToSOG(XmlTextReader reader, SceneObjectGroup sog)
+        {
+            reader.Read();
+            reader.ReadStartElement("SceneObjectGroup");
+            SceneObjectPart root = Xml2ToSOP(reader);
+            if (root != null)
+                sog.SetRootPart(root);
+            else
+            {
+                return false;
+            }
+
+            if (sog.UUID == UUID.Zero)
+                sog.UUID = sog.RootPart.UUID;
+
+            reader.Read(); // OtherParts
+
+            while (!reader.EOF)
+            {
+                switch (reader.NodeType)
+                {
+                    case XmlNodeType.Element:
+                        if (reader.Name == "SceneObjectPart")
+                        {
+                            SceneObjectPart child = Xml2ToSOP(reader);
+                            if (child != null)
+                                sog.AddPart(child);
+                        }
+                        else
+                        {
+                            //Logger.Log("Found unexpected prim XML element " + reader.Name, Helpers.LogLevel.Debug);
+                            reader.Read();
+                        }
+                        break;
+                    case XmlNodeType.EndElement:
+                    default:
+                        reader.Read();
+                        break;
+                }
+
+            }
+            return true;
+        }
+
+        public static SceneObjectPart Xml2ToSOP(XmlTextReader reader)
+        {
+            SceneObjectPart obj = new SceneObjectPart();
+
+            reader.ReadStartElement("SceneObjectPart");
+
+            string nodeName = string.Empty;
+            while (reader.NodeType != XmlNodeType.EndElement)
+            {
+                nodeName = reader.Name;
+                SOPXmlProcessor p = null;
+                if (m_SOPXmlProcessors.TryGetValue(reader.Name, out p))
+                {
+                    //m_log.DebugFormat("[XXX] Processing: {0}", reader.Name);
+                    try
+                    {
+                        p(obj, reader);
+                    }
+                    catch (Exception e)
+                    {
+                        m_log.DebugFormat("[SceneObjectSerializer]: exception while parsing {0}: {1}", nodeName, e);
+                        if (reader.NodeType == XmlNodeType.EndElement)
+                            reader.Read();
+                    }
+                }
+                else
+                {
+                    m_log.DebugFormat("[SceneObjectSerializer]: caught unknown element {0}", nodeName);
+                    reader.ReadOuterXml(); // ignore
+                }
+
+            }
+
+            reader.ReadEndElement(); // SceneObjectPart
+
+            //m_log.DebugFormat("[XXX]: parsed SOP {0} - {1}", obj.Name, obj.UUID);
+            return obj;
+        }
+
+        static UUID ReadUUID(XmlTextReader reader, string name)
+        {
+            UUID id;
+            string idStr;
+
+            reader.ReadStartElement(name);
+
+            if (reader.Name == "Guid")
+                idStr = reader.ReadElementString("Guid");
+            else // UUID
+                idStr = reader.ReadElementString("UUID");
+
+            UUID.TryParse(idStr, out id);
+            reader.ReadEndElement();
+
+            return id;
+        }
+
+        static Vector3 ReadVector(XmlTextReader reader, string name)
+        {
+            Vector3 vec;
+
+            reader.ReadStartElement(name);
+            vec.X = reader.ReadElementContentAsFloat("X", String.Empty);
+            vec.Y = reader.ReadElementContentAsFloat("Y", String.Empty);
+            vec.Z = reader.ReadElementContentAsFloat("Z", String.Empty);
+            reader.ReadEndElement();
+
+            return vec;
+        }
+
+        static Quaternion ReadQuaternion(XmlTextReader reader, string name)
+        {
+            Quaternion quat;
+
+            reader.ReadStartElement(name);
+            quat.X = reader.ReadElementContentAsFloat("X", String.Empty);
+            quat.Y = reader.ReadElementContentAsFloat("Y", String.Empty);
+            quat.Z = reader.ReadElementContentAsFloat("Z", String.Empty);
+            quat.W = reader.ReadElementContentAsFloat("W", String.Empty);
+            reader.ReadEndElement();
+
+            return quat;
+        }
+
+        static TaskInventoryDictionary ReadTaskInventory(XmlTextReader reader, string name)
+        {
+            TaskInventoryDictionary tinv = new TaskInventoryDictionary();
+
+            reader.ReadStartElement(name, String.Empty);
+
+            while (reader.Name == "TaskInventoryItem")
+            {
+                reader.ReadStartElement("TaskInventoryItem", String.Empty); // TaskInventory
+
+                TaskInventoryItem item = new TaskInventoryItem();
+                while (reader.NodeType != XmlNodeType.EndElement)
+                {
+                    TaskInventoryXmlProcessor p = null;
+                    if (m_TaskInventoryXmlProcessors.TryGetValue(reader.Name, out p))
+                        p(item, reader);
+                    else
+                    {
+                        m_log.DebugFormat("[SceneObjectSerializer]: caught unknown element in TaskInventory {0}, {1}", reader.Name, reader.Value);
+                        reader.ReadOuterXml();
+                    }
+                }
+                reader.ReadEndElement(); // TaskInventoryItem
+                tinv.Add(item.ItemID, item);
+
+            }
+
+            if (reader.NodeType == XmlNodeType.EndElement)
+                reader.ReadEndElement(); // TaskInventory
+
+            return tinv;
+        }
+
+        static PrimitiveBaseShape ReadShape(XmlTextReader reader, string name)
+        {
+            PrimitiveBaseShape shape = new PrimitiveBaseShape();
+
+            reader.ReadStartElement(name, String.Empty); // Shape
+
+            while (reader.NodeType != XmlNodeType.EndElement)
+            {
+                //m_log.DebugFormat("[XXX] Processing: {0}", reader.Name); 
+                ShapeXmlProcessor p = null;
+                if (m_ShapeXmlProcessors.TryGetValue(reader.Name, out p))
+                    p(shape, reader);
+                else
+                {
+                    m_log.DebugFormat("[SceneObjectSerializer]: caught unknown element in Shape {0}", reader.Name);
+                    reader.ReadOuterXml();
+                }
+            }
+
+            reader.ReadEndElement(); // Shape
+
+            return shape;
+        }
+
+        #endregion
     }
 }
diff --git a/OpenSim/Region/Framework/Scenes/Serialization/SceneXmlLoader.cs b/OpenSim/Region/Framework/Scenes/Serialization/SceneXmlLoader.cs
index 5494549..d214eba 100644
--- a/OpenSim/Region/Framework/Scenes/Serialization/SceneXmlLoader.cs
+++ b/OpenSim/Region/Framework/Scenes/Serialization/SceneXmlLoader.cs
@@ -45,6 +45,7 @@ namespace OpenSim.Region.Framework.Scenes.Serialization
     {
         private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
 
+        #region old xml format
         public static void LoadPrimsFromXml(Scene scene, string fileName, bool newIDS, Vector3 loadOffset)
         {
             XmlDocument doc = new XmlDocument();
@@ -98,11 +99,128 @@ namespace OpenSim.Region.Framework.Scenes.Serialization
             file.Close();
         }
 
-        public static string SaveGroupToXml2(SceneObjectGroup grp)
+        #endregion
+
+        #region XML2 serialization
+
+        // Called by archives (save oar)
+        public static string SaveGroupToXml2(SceneObjectGroup grp, Dictionary<string, object> options)
+        {
+            //return SceneObjectSerializer.ToXml2Format(grp);
+            using (MemoryStream mem = new MemoryStream())
+            {
+                using (XmlTextWriter writer = new XmlTextWriter(mem, System.Text.Encoding.UTF8))
+                {
+                    SceneObjectSerializer.SOGToXml2(writer, grp, options);
+                    writer.Flush();
+
+                    using (StreamReader reader = new StreamReader(mem))
+                    {
+                        mem.Seek(0, SeekOrigin.Begin);
+                        return reader.ReadToEnd();
+                    }
+                }
+            }
+        }
+
+        // Called by scene serializer (save xml2)
+        public static void SavePrimsToXml2(Scene scene, string fileName)
+        {
+            EntityBase[] entityList = scene.GetEntities();
+            SavePrimListToXml2(entityList, fileName);
+        }
+
+        // Called by scene serializer (save xml2)
+        public static void SaveNamedPrimsToXml2(Scene scene, string primName, string fileName)
+        {
+            m_log.InfoFormat(
+                "[SERIALISER]: Saving prims with name {0} in xml2 format for region {1} to {2}",
+                primName, scene.RegionInfo.RegionName, fileName);
+
+            EntityBase[] entityList = scene.GetEntities();
+            List<EntityBase> primList = new List<EntityBase>();
+
+            foreach (EntityBase ent in entityList)
+            {
+                if (ent is SceneObjectGroup)
+                {
+                    if (ent.Name == primName)
+                    {
+                        primList.Add(ent);
+                    }
+                }
+            }
+
+            SavePrimListToXml2(primList.ToArray(), fileName);
+        }
+
+        // Called by REST Application plugin
+        public static void SavePrimsToXml2(Scene scene, TextWriter stream, Vector3 min, Vector3 max)
         {
-            return SceneObjectSerializer.ToXml2Format(grp);
+            EntityBase[] entityList = scene.GetEntities();
+            SavePrimListToXml2(entityList, stream, min, max);
         }
 
+        // Called here only. Should be private?
+        public static void SavePrimListToXml2(EntityBase[] entityList, string fileName)
+        {
+            FileStream file = new FileStream(fileName, FileMode.Create);
+            try
+            {
+                StreamWriter stream = new StreamWriter(file);
+                try
+                {
+                    SavePrimListToXml2(entityList, stream, Vector3.Zero, Vector3.Zero);
+                }
+                finally
+                {
+                    stream.Close();
+                }
+            }
+            finally
+            {
+                file.Close();
+            }
+        }
+
+        // Called here only. Should be private?
+        public static void SavePrimListToXml2(EntityBase[] entityList, TextWriter stream, Vector3 min, Vector3 max)
+        {
+            XmlTextWriter writer = new XmlTextWriter(stream);
+
+            int primCount = 0;
+            stream.WriteLine("<scene>\n");
+
+            foreach (EntityBase ent in entityList)
+            {
+                if (ent is SceneObjectGroup)
+                {
+                    SceneObjectGroup g = (SceneObjectGroup)ent;
+                    if (!min.Equals(Vector3.Zero) || !max.Equals(Vector3.Zero))
+                    {
+                        Vector3 pos = g.RootPart.GetWorldPosition();
+                        if (min.X > pos.X || min.Y > pos.Y || min.Z > pos.Z)
+                            continue;
+                        if (max.X < pos.X || max.Y < pos.Y || max.Z < pos.Z)
+                            continue;
+                    }
+
+                    //stream.WriteLine(SceneObjectSerializer.ToXml2Format(g));
+                    SceneObjectSerializer.SOGToXml2(writer, (SceneObjectGroup)ent, new Dictionary<string,object>());
+                    stream.WriteLine();
+
+                    primCount++;
+                }
+            }
+
+            stream.WriteLine("</scene>\n");
+            stream.Flush();
+        }
+
+        #endregion
+
+        #region XML2 deserialization
+
         public static SceneObjectGroup DeserializeGroupFromXml2(string xmlString)
         {
             XmlDocument doc = new XmlDocument();
@@ -124,14 +242,30 @@ namespace OpenSim.Region.Framework.Scenes.Serialization
                 foreach (XmlNode aPrimNode in rootNode.ChildNodes)
                 {
                     // There is only ever one prim.  This oddity should be removeable post 0.5.9
-                    return SceneObjectSerializer.FromXml2Format(aPrimNode.OuterXml);
+                    //return SceneObjectSerializer.FromXml2Format(aPrimNode.OuterXml);
+                    using (reader = new XmlTextReader(new StringReader(aPrimNode.OuterXml)))
+                    {
+                        SceneObjectGroup obj = new SceneObjectGroup();
+                        if (SceneObjectSerializer.Xml2ToSOG(reader, obj))
+                            return obj;
+
+                        return null;
+                    }
                 }
 
                 return null;
             }
             else
             {
-                return SceneObjectSerializer.FromXml2Format(rootNode.OuterXml);
+                //return SceneObjectSerializer.FromXml2Format(rootNode.OuterXml);
+                using (reader = new XmlTextReader(new StringReader(rootNode.OuterXml)))
+                {
+                    SceneObjectGroup obj = new SceneObjectGroup();
+                    if (SceneObjectSerializer.Xml2ToSOG(reader, obj))
+                        return obj;
+
+                    return null;
+                }
             }
         }
 
@@ -193,96 +327,19 @@ namespace OpenSim.Region.Framework.Scenes.Serialization
         /// <returns>The scene object created.  null if the scene object already existed</returns>
         protected static SceneObjectGroup CreatePrimFromXml2(Scene scene, string xmlData)
         {
-            SceneObjectGroup obj = SceneObjectSerializer.FromXml2Format(xmlData);
-
-            if (scene.AddRestoredSceneObject(obj, true, false))
-                return obj;
-            else
-                return null;
-        }
-
-        public static void SavePrimsToXml2(Scene scene, string fileName)
-        {
-            EntityBase[] entityList = scene.GetEntities();
-            SavePrimListToXml2(entityList, fileName);
-        }
-
-        public static void SavePrimsToXml2(Scene scene, TextWriter stream, Vector3 min, Vector3 max)
-        {
-            EntityBase[] entityList = scene.GetEntities();
-            SavePrimListToXml2(entityList, stream, min, max);
-        }
-        
-        public static void SaveNamedPrimsToXml2(Scene scene, string primName, string fileName)
-        {
-            m_log.InfoFormat(
-                "[SERIALISER]: Saving prims with name {0} in xml2 format for region {1} to {2}", 
-                primName, scene.RegionInfo.RegionName, fileName);
-
-            EntityBase[] entityList = scene.GetEntities();
-            List<EntityBase> primList = new List<EntityBase>();
-
-            foreach (EntityBase ent in entityList)
-            {
-                if (ent is SceneObjectGroup)
-                {
-                    if (ent.Name == primName)
-                    {
-                        primList.Add(ent);
-                    }
-                }
-            }
-
-            SavePrimListToXml2(primList.ToArray(), fileName);
-        }
-
-        public static void SavePrimListToXml2(EntityBase[] entityList, string fileName)
-        {
-            FileStream file = new FileStream(fileName, FileMode.Create);
-            try
+            //SceneObjectGroup obj = SceneObjectSerializer.FromXml2Format(xmlData);
+            using (XmlTextReader reader = new XmlTextReader(new StringReader(xmlData)))
             {
-                StreamWriter stream = new StreamWriter(file);
-                try
-                {
-                    SavePrimListToXml2(entityList, stream, Vector3.Zero, Vector3.Zero);
-                }
-                finally
-                {
-                    stream.Close();
-                }
-            }
-            finally
-            {
-                file.Close();
-            }
-        }
+                SceneObjectGroup obj = new SceneObjectGroup();
+                SceneObjectSerializer.Xml2ToSOG(reader, obj);
 
-        public static void SavePrimListToXml2(EntityBase[] entityList, TextWriter stream, Vector3 min, Vector3 max)
-        {
-            int primCount = 0;
-            stream.WriteLine("<scene>\n");
-
-            foreach (EntityBase ent in entityList)
-            {
-                if (ent is SceneObjectGroup)
-                {
-                    SceneObjectGroup g = (SceneObjectGroup)ent;
-                    if (!min.Equals(Vector3.Zero) || !max.Equals(Vector3.Zero))
-                    {
-                        Vector3 pos = g.RootPart.GetWorldPosition();
-                        if (min.X > pos.X || min.Y > pos.Y || min.Z > pos.Z)
-                            continue;
-                        if (max.X < pos.X || max.Y < pos.Y || max.Z < pos.Z)
-                            continue;
-                    }
-
-                    stream.WriteLine(SceneObjectSerializer.ToXml2Format(g));
-                    primCount++;
-                }
+                if (scene.AddRestoredSceneObject(obj, true, false))
+                    return obj;
+                else
+                    return null;
             }
-            stream.WriteLine("</scene>\n");
-            stream.Flush();
         }
 
+        #endregion
     }
 }