few small changes

OpenSim/Framework/General/NullClientAPI.cs

@@ -0,0 +1,130 @@
+using System.Collections.Generic;
+using System.Net;
+using OpenSim.Framework.Interfaces;
+using OpenSim.Framework.Types;
+using OpenSim.Framework.Data;
+using libsecondlife;
+using libsecondlife.Packets;
+
+
+namespace OpenSim.Framework
+{
+   public  class NullClientAPI : IClientAPI
+   {
+#pragma warning disable 67
+       public event ImprovedInstantMessage OnInstantMessage;
+       public event ChatFromViewer OnChatFromViewer;
+       public event RezObject OnRezObject;
+       public event ModifyTerrain OnModifyTerrain;
+       public event SetAppearance OnSetAppearance;
+       public event StartAnim OnStartAnim;
+       public event LinkObjects OnLinkObjects;
+       public event RequestMapBlocks OnRequestMapBlocks;
+       public event TeleportLocationRequest OnTeleportLocationRequest;
+
+       public event GenericCall4 OnDeRezObject;
+       public event GenericCall OnRegionHandShakeReply;
+       public event GenericCall OnRequestWearables;
+       public event GenericCall2 OnCompleteMovementToRegion;
+       public event UpdateAgent OnAgentUpdate;
+       public event GenericCall OnRequestAvatarsData;
+       public event AddNewPrim OnAddPrim;
+       public event ObjectDuplicate OnObjectDuplicate;
+       public event UpdateVector OnGrapObject;
+       public event ObjectSelect OnDeGrapObject;
+       public event MoveObject OnGrapUpdate;
+
+       public event UpdateShape OnUpdatePrimShape;
+       public event ObjectSelect OnObjectSelect;
+       public event GenericCall7 OnObjectDescription;
+       public event GenericCall7 OnObjectName;
+       public event UpdatePrimFlags OnUpdatePrimFlags;
+       public event UpdatePrimTexture OnUpdatePrimTexture;
+       public event UpdateVector OnUpdatePrimGroupPosition;
+       public event UpdateVector OnUpdatePrimSinglePosition;
+       public event UpdatePrimRotation OnUpdatePrimGroupRotation;
+       public event UpdatePrimSingleRotation OnUpdatePrimSingleRotation;
+       public event UpdatePrimGroupRotation OnUpdatePrimGroupMouseRotation;
+       public event UpdateVector OnUpdatePrimScale;
+       public event StatusChange OnChildAgentStatus;
+       public event GenericCall2 OnStopMovement;
+       public event NewAvatar OnNewAvatar;
+       public event GenericCall6 OnRemoveAvatar;
+
+       public event UUIDNameRequest OnNameFromUUIDRequest;
+
+       public event ParcelPropertiesRequest OnParcelPropertiesRequest;
+       public event ParcelDivideRequest OnParcelDivideRequest;
+       public event ParcelJoinRequest OnParcelJoinRequest;
+       public event ParcelPropertiesUpdateRequest OnParcelPropertiesUpdateRequest;
+       public event ParcelSelectObjects OnParcelSelectObjects;
+       public event ParcelObjectOwnerRequest OnParcelObjectOwnerRequest;
+       public event ObjectDeselect OnObjectDeselect;
+
+
+       public event EstateOwnerMessageRequest OnEstateOwnerMessage;
+#pragma warning restore 67
+
+       private LLUUID m_uuid = LLUUID.Random();
+       public virtual LLVector3 StartPos
+       {
+           get { return new LLVector3(); }
+           set {  }
+       }
+
+       public virtual LLUUID AgentId
+       {
+           get { return m_uuid; }
+       }
+
+       public virtual string FirstName
+       {
+           get { return ""; }
+       }
+
+       public virtual string LastName
+       {
+           get { return ""; }
+       }
+
+       public NullClientAPI()
+       {
+       }
+
+       public virtual void OutPacket(Packet newPack){}
+       public virtual void SendWearables(AvatarWearable[] wearables){}
+       public virtual void SendStartPingCheck(byte seq){}
+       public virtual void SendKillObject(ulong regionHandle, uint avatarLocalID){}
+       public virtual void SendAnimation(LLUUID animID, int seq, LLUUID sourceAgentId){}
+       public virtual void SendRegionHandshake(RegionInfo regionInfo){}
+       public virtual void SendChatMessage(string message, byte type, LLVector3 fromPos, string fromName, LLUUID fromAgentID){}
+       public virtual void SendChatMessage(byte[] message, byte type, LLVector3 fromPos, string fromName, LLUUID fromAgentID){}
+       public virtual void SendInstantMessage(string message, LLUUID target, string fromName){}
+       public virtual void SendLayerData(float[] map){}
+       public virtual void SendLayerData(int px, int py, float[] map){}
+       public virtual void MoveAgentIntoRegion(RegionInfo regInfo, LLVector3 pos, LLVector3 look){}
+       public virtual void InformClientOfNeighbour(ulong neighbourHandle, IPEndPoint neighbourExternalEndPoint){}
+       public virtual AgentCircuitData RequestClientInfo() { return new AgentCircuitData(); }
+       public virtual void CrossRegion(ulong newRegionHandle, LLVector3 pos, LLVector3 lookAt, IPEndPoint newRegionExternalEndPoint){}
+       public virtual void SendMapBlock(List<MapBlockData> mapBlocks){}
+       public virtual void SendLocalTeleport(LLVector3 position, LLVector3 lookAt, uint flags){}
+       public virtual void SendRegionTeleport(ulong regionHandle, byte simAccess, IPEndPoint regionExternalEndPoint, uint locationID, uint flags){}
+       public virtual void SendTeleportCancel(){}
+       public virtual void SendTeleportLocationStart(){}
+       public virtual void SendMoneyBalance(LLUUID transaction, bool success, byte[] description, int balance){}
+
+       public virtual void SendAvatarData(ulong regionHandle, string firstName, string lastName, LLUUID avatarID, uint avatarLocalID, LLVector3 Pos, byte[] textureEntry){}
+       public virtual void SendAvatarTerseUpdate(ulong regionHandle, ushort timeDilation, uint localID, LLVector3 position, LLVector3 velocity){}
+
+       public virtual void AttachObject(uint localID, LLQuaternion rotation, byte attachPoint){}
+       public virtual void SendPrimitiveToClient(ulong regionHandle, ushort timeDilation, uint localID, PrimData primData, LLVector3 pos, LLQuaternion rotation, LLUUID textureID, uint flags){}
+       public virtual void SendPrimitiveToClient(ulong regionHandle, ushort timeDilation, uint localID, PrimData primData, LLVector3 pos, LLUUID textureID, uint flags){}
+       public virtual void SendPrimitiveToClient(ulong regionHandle, ushort timeDilation, uint localID, PrimitiveBaseShape primShape, LLVector3 pos, LLQuaternion rotation, uint flags, LLUUID objectID, LLUUID ownerID, string text, uint parentID){}
+       public virtual void SendPrimitiveToClient(ulong regionHandle, ushort timeDilation, uint localID, PrimitiveBaseShape primShape, LLVector3 pos, uint flags, LLUUID objectID, LLUUID ownerID, string text, uint parentID){}
+       public virtual void SendPrimTerseUpdate(ulong regionHandle, ushort timeDilation, uint localID, LLVector3 position, LLQuaternion rotation){}
+
+       public virtual void SendInventoryFolderDetails(LLUUID ownerID, LLUUID folderID, List<InventoryItemBase> items){}
+       public virtual void SendInventoryItemDetails(LLUUID ownerID, LLUUID folderID, InventoryItemBase item){}
+       public virtual void SendNameReply(LLUUID profileId, string firstname, string lastname){}
+    }
+}

OpenSim/Region/Communications/OGS1/OGS1GridServices.cs

@@ -354,7 +354,6 @@ namespace OpenSim.Region.Communications.OGS1
                         "tcp://" + regInfo.RemotingAddress + ":" + regInfo.RemotingPort + "/InterRegions");
                     if (remObject != null)
                     {
-
                         retValue = remObject.InformRegionOfChildAgent(regionHandle, agentData);
                     }
                     else
@@ -396,14 +395,11 @@ namespace OpenSim.Region.Communications.OGS1
                 if (regInfo != null)
                 {
                     bool retValue = false;
-
-
                     OGS1InterRegionRemoting remObject = (OGS1InterRegionRemoting)Activator.GetObject(
                         typeof(OGS1InterRegionRemoting),
                         "tcp://" + regInfo.RemotingAddress + ":" + regInfo.RemotingPort + "/InterRegions");
                     if (remObject != null)
                     {
-
                         retValue = remObject.ExpectAvatarCrossing(regionHandle, agentID, position);
                     }
                     else
@@ -412,7 +408,6 @@ namespace OpenSim.Region.Communications.OGS1
                     }
                     remObject = null;
 
-
                     return retValue;
                 }
                 //TODO need to see if we know about where this region is and use .net remoting 

OpenSim/Region/Communications/OGS1/OGS1UserServices.cs

@@ -69,7 +69,6 @@ namespace OpenSim.Region.Communications.OGS1
         {
             try
             {
-
                 Hashtable param = new Hashtable();
                 param["avatar_uuid"] = avatarID.ToString();
                 IList parameters = new ArrayList();

OpenSim/Region/Environment/Scenes/AllNewSceneObjectGroup.cs

@@ -0,0 +1,244 @@
+using System.Collections.Generic;
+using System.Text;
+using Axiom.Math;
+using libsecondlife;
+using libsecondlife.Packets;
+using OpenSim.Framework.Interfaces;
+using OpenSim.Framework.Types;
+using OpenSim.Physics.Manager;
+
+namespace OpenSim.Region.Environment.Scenes
+{
+    public delegate void PrimCountTaintedDelegate();
+
+    public class AllNewSceneObjectGroup : EntityBase
+    {
+        private Encoding enc = Encoding.ASCII;
+
+        protected AllNewSceneObjectPart m_rootPart;
+        protected Dictionary<LLUUID, AllNewSceneObjectPart> m_parts = new Dictionary<LLUUID, AllNewSceneObjectPart>();
+
+        public event PrimCountTaintedDelegate OnPrimCountTainted;
+
+        /// <summary>
+        /// 
+        /// </summary>
+        public int primCount
+        {
+            get
+            {
+                return 1;
+            }
+        }
+
+        /// <summary>
+        /// 
+        /// </summary>
+        public LLVector3 GroupCentrePoint
+        {
+            get
+            {
+                return new LLVector3(0, 0, 0);
+            }
+        }
+
+        /// <summary>
+        /// 
+        /// </summary>
+        public AllNewSceneObjectGroup()
+        {
+
+        }
+
+        /// <summary>
+        /// 
+        /// </summary>
+        public void FlagGroupForFullUpdate()
+        {
+
+        }
+
+        /// <summary>
+        /// 
+        /// </summary>
+        public void FlagGroupForTerseUpdate()
+        {
+
+        }
+
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="objectGroup"></param>
+        public void LinkToGroup(AllNewSceneObjectGroup objectGroup)
+        {
+
+        }
+
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="primID"></param>
+        /// <returns></returns>
+        public AllNewSceneObjectPart HasChildPrim(LLUUID primID)
+        {
+            AllNewSceneObjectPart childPart = null;
+            if (this.m_parts.ContainsKey(primID))
+            {
+                childPart = this.m_parts[primID];
+            }
+            return childPart;
+        }
+
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="localID"></param>
+        /// <returns></returns>
+        public AllNewSceneObjectPart HasChildPrim(uint localID)
+        {
+            foreach (AllNewSceneObjectPart part in this.m_parts.Values)
+            {
+                if (part.m_localID == localID)
+                {
+                    return part;
+                }
+            }
+            return null;
+        }
+
+        public void TriggerTainted()
+        {
+            if (OnPrimCountTainted != null)
+            {
+                this.OnPrimCountTainted();
+            }
+        }
+
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="offset"></param>
+        /// <param name="pos"></param>
+        /// <param name="remoteClient"></param>
+        public void GrapMovement(LLVector3 offset, LLVector3 pos, IClientAPI remoteClient)
+        {
+            this.Pos = pos;
+        }
+
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="client"></param>
+        public void GetProperites(IClientAPI client)
+        {
+            ObjectPropertiesPacket proper = new ObjectPropertiesPacket();
+            proper.ObjectData = new ObjectPropertiesPacket.ObjectDataBlock[1];
+            proper.ObjectData[0] = new ObjectPropertiesPacket.ObjectDataBlock();
+            proper.ObjectData[0].ItemID = LLUUID.Zero;
+            proper.ObjectData[0].CreationDate = (ulong)this.m_rootPart.CreationDate;
+            proper.ObjectData[0].CreatorID = this.m_rootPart.CreatorID;
+            proper.ObjectData[0].FolderID = LLUUID.Zero;
+            proper.ObjectData[0].FromTaskID = LLUUID.Zero;
+            proper.ObjectData[0].GroupID = LLUUID.Zero;
+            proper.ObjectData[0].InventorySerial = 0;
+            proper.ObjectData[0].LastOwnerID = this.m_rootPart.LastOwnerID;
+            proper.ObjectData[0].ObjectID = this.m_uuid;
+            proper.ObjectData[0].OwnerID = this.m_rootPart.OwnerID;
+            proper.ObjectData[0].TouchName = enc.GetBytes(this.m_rootPart.TouchName + "\0");
+            proper.ObjectData[0].TextureID = new byte[0];
+            proper.ObjectData[0].SitName = enc.GetBytes(this.m_rootPart.SitName + "\0");
+            proper.ObjectData[0].Name = enc.GetBytes(this.m_rootPart.Name + "\0");
+            proper.ObjectData[0].Description = enc.GetBytes(this.m_rootPart.Description + "\0");
+            proper.ObjectData[0].OwnerMask = this.m_rootPart.OwnerMask;
+            proper.ObjectData[0].NextOwnerMask = this.m_rootPart.NextOwnerMask;
+            proper.ObjectData[0].GroupMask = this.m_rootPart.GroupMask;
+            proper.ObjectData[0].EveryoneMask = this.m_rootPart.EveryoneMask;
+            proper.ObjectData[0].BaseMask = this.m_rootPart.BaseMask;
+
+            client.OutPacket(proper);
+        }
+
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="part"></param>
+        private void SetPartAsRoot(AllNewSceneObjectPart part)
+        {
+            this.m_rootPart = part;
+            this.m_uuid = part.uuid;
+            this.m_localId = part.m_localID;
+            part.ParentID = 0;
+            part.UpdateHandler = delegate(ref LLVector3 pos, UpdateType direction, AllNewSceneObjectPart objectPart)
+            {
+                switch (direction)
+                {
+                    case UpdateType.InComingNewPosition:
+                        this.m_pos = new LLVector3(pos.X, pos.Y, pos.Z);
+                        pos.X = 0;
+                        pos.Y = 0;
+                        pos.Z = 0;
+                        break;
+
+                    case UpdateType.SinglePositionEdit:
+                        LLVector3 newPos = new LLVector3(pos.X, pos.Y, pos.Z);
+                        LLVector3 oldPos = new LLVector3(this.Pos.X + objectPart.OffsetPosition.X, this.Pos.Y + objectPart.OffsetPosition.Y, this.Pos.Z + objectPart.OffsetPosition.Z);
+                        LLVector3 diff = oldPos - newPos;
+                        Axiom.Math.Vector3 axDiff = new Vector3(diff.X, diff.Y, diff.Z);
+                        Axiom.Math.Quaternion partRotation = new Quaternion(objectPart.RotationOffset.W, objectPart.RotationOffset.X, objectPart.RotationOffset.Y, objectPart.RotationOffset.Z);
+                        axDiff = partRotation.Inverse() * axDiff;
+                        diff.X = axDiff.x;
+                        diff.Y = axDiff.y;
+                        diff.Z = axDiff.z;
+
+                        foreach (AllNewSceneObjectPart obPart in this.m_parts.Values)
+                        {
+                            if (obPart.uuid == objectPart.uuid)
+                            {
+                                obPart.OffsetPosition = obPart.OffsetPosition + diff;
+                            }
+                        }
+                        this.Pos = newPos;
+                        pos.X = newPos.X;
+                        pos.Y = newPos.Y;
+                        pos.Z = newPos.Z;
+                        break;
+
+                    case UpdateType.ResizeOffset:
+                        this.Pos += pos;
+                        LLVector3 offset = new LLVector3(-pos.X, -pos.Y, -pos.Z);
+                        foreach (AllNewSceneObjectPart obPart2 in this.m_parts.Values)
+                        {
+                            if (obPart2.uuid == objectPart.uuid)
+                            {
+                                obPart2.OffsetPosition = obPart2.OffsetPosition + offset;
+                            }
+                        }
+                        pos.X = 0;
+                        pos.Y = 0;
+                        pos.Z = 0;
+                        break;
+
+                    case UpdateType.SingleRotationEdit:
+                        break;
+                }
+
+
+                return pos;
+            };
+        }
+
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="part"></param>
+        private void SetPartAsNonRoot(AllNewSceneObjectPart part)
+        {
+            part.ParentID = this.m_rootPart.m_localID;
+            part.UpdateHandler = delegate(ref LLVector3 pos, UpdateType direction, AllNewSceneObjectPart objectPart)
+            {
+                return pos;
+            };
+        }
+    }
+}

OpenSim/Region/Environment/Scenes/AllNewSceneObjectPart.cs

@@ -0,0 +1,258 @@
+using System.Collections.Generic;
+using System.Text;
+using System;
+using Axiom.Math;
+using libsecondlife;
+using libsecondlife.Packets;
+using OpenSim.Framework.Interfaces;
+using OpenSim.Framework.Types;
+
+namespace OpenSim.Region.Environment.Scenes
+{
+    public enum UpdateType
+    {
+        OutGoingOffset,
+        InComingNewPosition,
+        SinglePositionEdit, 
+        ResizeOffset,
+        SingleRotationEdit
+    }
+
+    public delegate LLVector3 HandleUpdate(ref LLVector3 pos, UpdateType updateType, AllNewSceneObjectPart objectPart);
+
+    public class AllNewSceneObjectPart
+    {
+        private const uint FULL_MASK_PERMISSIONS = 2147483647;
+
+        private ulong m_regionHandle;
+        private uint m_flags = 32 + 65536 + 131072 + 256 + 4 + 8 + 2048 + 524288 + 268435456 + 128;
+        //private Dictionary<LLUUID, InventoryItem> inventoryItems;
+
+        public string SitName = "";
+        public string TouchName = "";
+        public string Text = "";
+
+        public LLUUID CreatorID;
+        public LLUUID OwnerID;
+        public LLUUID LastOwnerID;
+        public Int32 CreationDate;
+
+        public LLUUID uuid;
+        public uint m_localID;
+
+        public uint ParentID = 0;
+
+        public uint OwnerMask = FULL_MASK_PERMISSIONS;
+        public uint NextOwnerMask = FULL_MASK_PERMISSIONS;
+        public uint GroupMask = FULL_MASK_PERMISSIONS;
+        public uint EveryoneMask = FULL_MASK_PERMISSIONS;
+        public uint BaseMask = FULL_MASK_PERMISSIONS;
+
+        protected PrimitiveBaseShape m_Shape;
+
+        protected AllNewSceneObjectGroup m_parentGroup;
+
+        public HandleUpdate UpdateHandler;
+
+        #region Properties
+        protected string m_name;
+        /// <summary>
+        /// 
+        /// </summary>
+        public virtual string Name
+        {
+            get { return m_name; }
+            set { m_name = value; }
+        }
+
+        protected LLVector3 m_offset;
+        public LLVector3 OffsetPosition
+        {
+            get
+            {
+                return m_offset;
+            }
+            set
+            {
+                m_offset = value;
+            }
+        }
+
+        protected LLQuaternion m_rotationOffset;
+        public LLQuaternion RotationOffset
+        {
+            get
+            {
+                return m_rotationOffset;
+            }
+            set
+            {
+                m_rotationOffset = value;
+            }
+        }
+
+        private string m_description = "";
+        public string Description
+        {
+            get
+            {
+                return this.m_description;
+            }
+            set
+            {
+                this.m_description = value;
+            }
+        }
+
+        public PrimitiveBaseShape Shape
+        {
+            get
+            {
+                return this.m_Shape;
+            }
+        }
+
+        public LLVector3 Scale
+        {
+            set
+            {
+                this.m_Shape.Scale = value;
+            }
+            get
+            {
+                return this.m_Shape.Scale;
+            }
+        }
+        #endregion
+
+        #region Constructors
+        public AllNewSceneObjectPart(ulong regionHandle, AllNewSceneObjectGroup parent, LLUUID ownerID, uint localID, PrimitiveBaseShape shape, LLVector3 position)
+        {
+            this.m_regionHandle = regionHandle;
+            this.m_parentGroup = parent;
+
+            this.CreationDate = (Int32)(DateTime.UtcNow - new DateTime(1970, 1, 1)).TotalSeconds;
+            this.OwnerID = ownerID;
+            this.CreatorID = this.OwnerID;
+            this.LastOwnerID = LLUUID.Zero;
+            this.uuid = LLUUID.Random();
+            this.m_localID = (uint)(localID);
+            this.m_Shape = shape;
+
+            this.UpdateHandler(ref position, UpdateType.InComingNewPosition, this);
+            this.OffsetPosition = position;
+        }
+        #endregion
+
+        #region Shape
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="shapeBlock"></param>
+        public void UpdateShape(ObjectShapePacket.ObjectDataBlock shapeBlock)
+        {
+            this.m_Shape.PathBegin = shapeBlock.PathBegin;
+            this.m_Shape.PathEnd = shapeBlock.PathEnd;
+            this.m_Shape.PathScaleX = shapeBlock.PathScaleX;
+            this.m_Shape.PathScaleY = shapeBlock.PathScaleY;
+            this.m_Shape.PathShearX = shapeBlock.PathShearX;
+            this.m_Shape.PathShearY = shapeBlock.PathShearY;
+            this.m_Shape.PathSkew = shapeBlock.PathSkew;
+            this.m_Shape.ProfileBegin = shapeBlock.ProfileBegin;
+            this.m_Shape.ProfileEnd = shapeBlock.ProfileEnd;
+            this.m_Shape.PathCurve = shapeBlock.PathCurve;
+            this.m_Shape.ProfileCurve = shapeBlock.ProfileCurve;
+            this.m_Shape.ProfileHollow = shapeBlock.ProfileHollow;
+            this.m_Shape.PathRadiusOffset = shapeBlock.PathRadiusOffset;
+            this.m_Shape.PathRevolutions = shapeBlock.PathRevolutions;
+            this.m_Shape.PathTaperX = shapeBlock.PathTaperX;
+            this.m_Shape.PathTaperY = shapeBlock.PathTaperY;
+            this.m_Shape.PathTwist = shapeBlock.PathTwist;
+            this.m_Shape.PathTwistBegin = shapeBlock.PathTwistBegin;
+        }
+        #endregion
+
+        #region Texture
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="textureEntry"></param>
+        public void UpdateTextureEntry(byte[] textureEntry)
+        {
+            this.m_Shape.TextureEntry = textureEntry;
+        }
+        #endregion
+
+        #region Position
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="pos"></param>
+        public void UpdateGroupPosition(LLVector3 pos)
+        {
+            LLVector3 newPos = new LLVector3(pos.X, pos.Y, pos.Z);
+            this.UpdateHandler(ref newPos, UpdateType.InComingNewPosition, this);
+            this.OffsetPosition = newPos;
+        }
+
+        public void UpdateSinglePosition(LLVector3 pos)
+        {
+            LLVector3 newPos = new LLVector3(pos.X, pos.Y, pos.Z);
+            this.UpdateHandler(ref newPos, UpdateType.SinglePositionEdit, this);
+            this.OffsetPosition = newPos;
+        }
+        #endregion
+
+        #region rotation
+        public void UpdateGroupRotation(LLQuaternion rot)
+        {
+            this.RotationOffset = new LLQuaternion(rot.X, rot.Y, rot.Z, rot.W);
+        }
+
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="pos"></param>
+        /// <param name="rot"></param>
+        public void UpdateGroupMouseRotation(LLVector3 pos, LLQuaternion rot)
+        {
+            this.RotationOffset = new LLQuaternion(rot.X, rot.Y, rot.Z, rot.W);
+            this.UpdateHandler(ref pos, UpdateType.InComingNewPosition, this);
+            this.OffsetPosition = pos;
+        }
+
+         /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="rot"></param>
+        public void UpdateSingleRotation(LLQuaternion rot)
+        {
+            //Console.WriteLine("updating single prim rotation");
+            Axiom.Math.Quaternion axRot = new Quaternion(rot.W, rot.X, rot.Y, rot.Z);
+            Axiom.Math.Quaternion oldParentRot = new Quaternion(this.RotationOffset.W, this.RotationOffset.X, this.RotationOffset.Y, this.RotationOffset.Z);
+            this.RotationOffset = new LLQuaternion(axRot.x, axRot.y, axRot.z, axRot.w);
+
+            LLVector3 offset = this.OffsetPosition;
+            this.UpdateHandler(ref offset, UpdateType.SingleRotationEdit, this);
+        }
+        #endregion
+
+        #region Resizing/Scale
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="scale"></param>
+        public void ResizeGoup(LLVector3 scale)
+        {
+            LLVector3 offset = (scale - this.m_Shape.Scale);
+            offset.X /= 2;
+            offset.Y /= 2;
+            offset.Z /= 2;
+
+            this.UpdateHandler(ref offset, UpdateType.ResizeOffset, this);
+            this.OffsetPosition += offset;
+            this.m_Shape.Scale = scale;
+        }
+        #endregion
+    }
+}

OpenSim/Region/Environment/Scenes/EntityBase.cs

@@ -7,9 +7,10 @@ namespace OpenSim.Region.Environment.Scenes
     public abstract class EntityBase
     {
         public LLUUID m_uuid;
-       
+
         protected List<EntityBase> m_children;
 
+
         protected Scene m_world;
         protected string m_name;
 
@@ -88,7 +89,9 @@ namespace OpenSim.Region.Environment.Scenes
             m_velocity = new LLVector3();
             Rotation = new Quaternion();
             m_name = "(basic entity)";
+
             m_children = new List<EntityBase>();
+
         }
 
         /// <summary>
@@ -96,7 +99,9 @@ namespace OpenSim.Region.Environment.Scenes
         /// </summary>
         public virtual void updateMovement()
         {
+
             foreach (EntityBase child in m_children)
+
             {
                 child.updateMovement();
             }
@@ -108,6 +113,7 @@ namespace OpenSim.Region.Environment.Scenes
         public virtual void Update()
         {
             // Do any per-frame updates needed that are applicable to every type of entity
+
             foreach (EntityBase child in m_children)
             {
                 child.Update();

OpenSim/Region/Environment/Scenes/Primitive.cs

@@ -9,7 +9,7 @@ using OpenSim.Framework.Types;
 
 namespace OpenSim.Region.Environment.Scenes
 {
-    public delegate void PrimCountTaintedDelegate();
+   // public delegate void PrimCountTaintedDelegate();
 
     public class Primitive : EntityBase
     {
@@ -198,12 +198,14 @@ namespace OpenSim.Region.Environment.Scenes
             dupe.m_RootParent = rootParent;
 
             // TODO: Copy this properly.
+
             dupe.m_inventoryItems = m_inventoryItems;
             dupe.m_children = new List<EntityBase>();
             dupe.m_Shape = m_Shape.Copy();
             dupe.m_regionHandle = m_regionHandle;
             dupe.m_world = m_world;
 
+
             uint newLocalID = m_world.PrimIDAllocate();
             dupe.m_uuid = LLUUID.Random();
             dupe.LocalId = newLocalID;
@@ -227,9 +229,11 @@ namespace OpenSim.Region.Environment.Scenes
             m_world.AcknowledgeNewPrim(dupe);
             dupe.TriggerOnPrimCountTainted();
 
+
             foreach (Primitive prim in m_children)
             {
                 Primitive primClone = prim.Copy(dupe, rootParent);
+
                 dupe.m_children.Add(primClone);
             }
 
@@ -320,6 +324,7 @@ namespace OpenSim.Region.Environment.Scenes
         {
             // Console.WriteLine("linking new prims " + linkObject.rootLocalID + " to me (" + this.LocalId + ")");
             //TODO check permissions
+
             m_children.Add(linkObject.rootPrimitive);
             linkObject.rootPrimitive.SetNewParent(this, m_RootParent);
 
@@ -350,11 +355,14 @@ namespace OpenSim.Region.Environment.Scenes
             Rotation = m_Parent.Rotation.Inverse() * Rotation;
             ScheduleFullUpdate();
 
+
             foreach (Primitive child in m_children)
             {
                 child.SetRootParent(rootParent, newParent, oldPos, oldRot);
             }
+
             m_children.Clear();
+
         }
 
         /// <summary>
@@ -374,6 +382,7 @@ namespace OpenSim.Region.Environment.Scenes
             m_Parent = newParent;
             ParentID = newParent.LocalId;
             newParent.AddToChildrenList(this);
+
             m_RootParent = newRoot;
             m_RootParent.AddChildToList(this);
             Pos = oldPos;
@@ -387,7 +396,9 @@ namespace OpenSim.Region.Environment.Scenes
             {
                 child.SetRootParent(newRoot, newParent, oldPos, oldRot);
             }
+
             m_children.Clear();
+
         }
 
         /// <summary>
@@ -527,6 +538,7 @@ namespace OpenSim.Region.Environment.Scenes
         public void UpdateSingleRotation(LLQuaternion rot)
         {
             //Console.WriteLine("updating single prim rotation");
+
             Quaternion axRot = new Quaternion(rot.W, rot.X, rot.Y, rot.Z);
             Quaternion oldParentRot = new Quaternion(Rotation.w, Rotation.x, Rotation.y, Rotation.z);
             Rotation = axRot;
@@ -598,9 +610,12 @@ namespace OpenSim.Region.Environment.Scenes
         /// <param name="remoteClient"></param>
         public void SendFullUpdateForAllChildren(IClientAPI remoteClient)
         {
+
             SendFullUpdateToClient(remoteClient);
             for (int i = 0; i < m_children.Count; i++)
+
             {
+
                 if (m_children[i] is Primitive)
                 {
                     ((Primitive)m_children[i]).SendFullUpdateForAllChildren(remoteClient);
@@ -641,6 +656,7 @@ namespace OpenSim.Region.Environment.Scenes
         /// <param name="remoteClient"></param>
         public void SendTerseUpdateForAllChildren(IClientAPI remoteClient)
         {
+
             SendTerseUpdateToClient(remoteClient);
             for (int i = 0; i < m_children.Count; i++)
             {

OpenSim/Region/Environment/Scenes/Scene.cs

@@ -707,6 +707,10 @@ namespace OpenSim.Region.Environment.Scenes
             return null;
         }
 
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="whatToDo"></param>
         public void ForEachScenePresence(ForEachScenePresenceDelegate whatToDo)
         {
             foreach (ScenePresence presence in Avatars.Values)

OpenSim/Region/Environment/Scenes/SceneObject.cs

@@ -150,8 +150,8 @@ namespace OpenSim.Region.Environment.Scenes
         {
 
             this.rootPrimitive = new Primitive(this.m_regionHandle, this.m_world, agentID, localID, true, this, this, shape, pos);
-
             this.m_children.Add(rootPrimitive);
+
             this.ChildPrimitives.Add(this.rootUUID, this.rootPrimitive);
         }
 
@@ -177,6 +177,7 @@ namespace OpenSim.Region.Environment.Scenes
             dupe.m_regionHandle = this.m_regionHandle;
             Primitive newRoot = this.rootPrimitive.Copy(dupe, dupe);
             dupe.rootPrimitive = newRoot;
+
             dupe.m_children.Add(dupe.rootPrimitive);
             dupe.rootPrimitive.Pos = this.Pos;
             dupe.Rotation = this.Rotation;