1 files changed, 1124 insertions, 535 deletions

diff --git a/OpenSim/Region/Framework/Scenes/SceneObjectPart.cs b/OpenSim/Region/Framework/Scenes/SceneObjectPart.cs
index b00f388..415a82b 100644
--- a/OpenSim/Region/Framework/Scenes/SceneObjectPart.cs
+++ b/OpenSim/Region/Framework/Scenes/SceneObjectPart.cs
@@ -63,7 +63,8 @@ namespace OpenSim.Region.Framework.Scenes
         TELEPORT = 512,
         REGION_RESTART = 1024,
         MEDIA = 2048,
-        ANIMATION = 16384
+        ANIMATION = 16384,
+        POSITION = 32768
     }
 
     // I don't really know where to put this except here.
@@ -122,7 +123,18 @@ namespace OpenSim.Region.Framework.Scenes
         /// Denote all sides of the prim
         /// </value>
         public const int ALL_SIDES = -1;
-        
+
+        private const scriptEvents PhysicsNeededSubsEvents = (
+                    scriptEvents.collision | scriptEvents.collision_start | scriptEvents.collision_end |
+                    scriptEvents.land_collision | scriptEvents.land_collision_start | scriptEvents.land_collision_end
+                    );
+        private const scriptEvents PhyscicsPhantonSubsEvents = (
+                    scriptEvents.land_collision | scriptEvents.land_collision_start | scriptEvents.land_collision_end
+                    );
+        private const scriptEvents PhyscicsVolumeDtcSubsEvents = (
+                    scriptEvents.collision_start | scriptEvents.collision_end
+                    );      
+
         private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
 
         /// <summary>
@@ -138,7 +150,7 @@ namespace OpenSim.Region.Framework.Scenes
         /// </remarks>
         public bool IsRoot 
         {
-            get { return ParentGroup.RootPart == this; } 
+            get { return Object.ReferenceEquals(ParentGroup.RootPart, this); } 
         }
 
         /// <summary>
@@ -197,12 +209,25 @@ namespace OpenSim.Region.Framework.Scenes
 
         public double SoundRadius;
 
+
         public uint TimeStampFull;
 
         public uint TimeStampLastActivity; // Will be used for AutoReturn
 
         public uint TimeStampTerse;
 
+        // The following two are to hold the attachment data
+        // while an object is inworld
+        [XmlIgnore]
+        public byte AttachPoint = 0;
+
+        [XmlIgnore]
+        public Vector3 AttachOffset = Vector3.Zero;
+
+        [XmlIgnore]
+        public Quaternion AttachRotation = Quaternion.Identity;
+
+        [XmlIgnore]
         public int STATUS_ROTATE_X;
 
         public int STATUS_ROTATE_Y;
@@ -229,8 +254,7 @@ namespace OpenSim.Region.Framework.Scenes
 
         public Vector3 RotationAxis = Vector3.One;
 
-        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
+        public bool VolumeDetectActive;
 
         public bool IsWaitingForFirstSpinUpdatePacket;
 
@@ -270,10 +294,10 @@ namespace OpenSim.Region.Framework.Scenes
         private Quaternion m_sitTargetOrientation = Quaternion.Identity;
         private Vector3 m_sitTargetPosition;
         private string m_sitAnimation = "SIT";
+        private bool m_occupied;                                        // KF if any av is sitting on this prim
         private string m_text = String.Empty;
         private string m_touchName = String.Empty;
-        private readonly List<UndoState> m_undo = new List<UndoState>(5);
-        private readonly List<UndoState> m_redo = new List<UndoState>(5);
+        private UndoRedoState m_UndoRedo = null;
 
         private bool m_passTouches = false;
         private bool m_passCollisions = false;
@@ -301,15 +325,20 @@ namespace OpenSim.Region.Framework.Scenes
         protected Vector3 m_lastVelocity;
         protected Vector3 m_lastAcceleration;
         protected Vector3 m_lastAngularVelocity;
-        protected int m_lastTerseSent;
+        protected int m_lastUpdateSentTime;
+        protected float m_buoyancy = 0.0f;
+        protected Vector3 m_force;
+        protected Vector3 m_torque;
 
         protected byte m_physicsShapeType = (byte)PhysShapeType.prim;
-        // TODO: Implement these
-        //protected float m_density = 1000.0f; // in kg/m^3
-        //protected float m_gravitymod = 1.0f;
-        //protected float m_friction = 0.6f; // wood
-        //protected float m_bounce = 0.5f; // wood
-        
+        protected float m_density = 1000.0f; // in kg/m^3
+        protected float m_gravitymod = 1.0f;
+        protected float m_friction = 0.6f; // wood
+        protected float m_bounce = 0.5f; // wood
+
+
+        protected bool m_isSelected = false;
+
         /// <summary>
         /// Stores media texture data
         /// </summary>
@@ -321,10 +350,25 @@ namespace OpenSim.Region.Framework.Scenes
         private Vector3 m_cameraAtOffset;
         private bool m_forceMouselook;
 
-        // TODO: Collision sound should have default.
+
+        // 0 for default collision sounds, -1 for script disabled sound 1 for script defined sound
+        private sbyte m_collisionSoundType;
         private UUID m_collisionSound;
         private float m_collisionSoundVolume;
 
+        private int LastColSoundSentTime; 
+
+
+        private SOPVehicle m_vehicleParams = null;
+
+        private KeyframeMotion m_keyframeMotion = null;
+
+        public KeyframeMotion KeyframeMotion
+        {
+            get; set;
+        }
+
+
         #endregion Fields
 
 //        ~SceneObjectPart()
@@ -354,6 +398,7 @@ namespace OpenSim.Region.Framework.Scenes
             // this appears to have the same UUID (!) as the prim.  If this isn't the case, one can't drag items from
             // the prim into an agent inventory (Linden client reports that the "Object not found for drop" in its log
             m_inventory = new SceneObjectPartInventory(this);
+            LastColSoundSentTime = Util.EnvironmentTickCount();
         }
 
         /// <summary>
@@ -368,7 +413,7 @@ namespace OpenSim.Region.Framework.Scenes
             UUID ownerID, PrimitiveBaseShape shape, Vector3 groupPosition, 
             Quaternion rotationOffset, Vector3 offsetPosition) : this()
         {
-            m_name = "Primitive";
+            m_name = "Object";
 
             CreationDate = (int)Utils.DateTimeToUnixTime(Rezzed);
             LastOwnerID = CreatorID = OwnerID = ownerID;
@@ -407,7 +452,7 @@ namespace OpenSim.Region.Framework.Scenes
         private uint _ownerMask = (uint)PermissionMask.All;
         private uint _groupMask = (uint)PermissionMask.None;
         private uint _everyoneMask = (uint)PermissionMask.None;
-        private uint _nextOwnerMask = (uint)PermissionMask.All;
+        private uint _nextOwnerMask = (uint)(PermissionMask.Move | PermissionMask.Modify | PermissionMask.Transfer);
         private PrimFlags _flags = PrimFlags.None;
         private DateTime m_expires;
         private DateTime m_rezzed;
@@ -501,12 +546,16 @@ namespace OpenSim.Region.Framework.Scenes
         }
 
         /// <value>
-        /// Access should be via Inventory directly - this property temporarily remains for xml serialization purposes
+        /// Get the inventory list
         /// </value>
         public TaskInventoryDictionary TaskInventory
         {
-            get { return m_inventory.Items; }
-            set { m_inventory.Items = value; }
+            get {
+                return m_inventory.Items;
+            }
+            set {
+                m_inventory.Items = value;
+            }
         }
 
         /// <summary>
@@ -556,20 +605,6 @@ namespace OpenSim.Region.Framework.Scenes
             }
         }
 
-        public byte Material
-        {
-            get { return (byte) m_material; }
-            set
-            {
-                m_material = (Material)value;
-
-                PhysicsActor pa = PhysActor;
-
-                if (pa != null)
-                    pa.SetMaterial((int)value);
-            }
-        }
-
         [XmlIgnore]
         public bool PassTouches
         {
@@ -595,6 +630,18 @@ namespace OpenSim.Region.Framework.Scenes
             }
         }
 
+        public bool IsSelected
+        {
+            get { return m_isSelected; }
+            set
+            {
+                m_isSelected = value;
+                if (ParentGroup != null)
+                    ParentGroup.PartSelectChanged(value);
+            }
+        }
+        
+        
         public Dictionary<int, string> CollisionFilter
         {
             get { return m_CollisionFilter; }
@@ -663,14 +710,12 @@ namespace OpenSim.Region.Framework.Scenes
             set { m_LoopSoundSlavePrims = value; }
         }
 
-        
         public Byte[] TextureAnimation
         {
             get { return m_TextureAnimation; }
             set { m_TextureAnimation = value; }
         }
 
-        
         public Byte[] ParticleSystem
         {
             get { return m_particleSystem; }
@@ -707,9 +752,12 @@ namespace OpenSim.Region.Framework.Scenes
             {
                 // If this is a linkset, we don't want the physics engine mucking up our group position here.
                 PhysicsActor actor = PhysActor;
-                // If physical and the root prim of a linkset, the position of the group is what physics thinks.
-                if (actor != null && ParentID == 0)
-                    m_groupPosition = actor.Position;
+                if (ParentID == 0)
+                {
+                    if (actor != null)
+                        m_groupPosition = actor.Position;
+                    return m_groupPosition;
+                }
 
                 // If I'm an attachment, my position is reported as the position of who I'm attached to
                 if (ParentGroup.IsAttachment)
@@ -719,14 +767,16 @@ namespace OpenSim.Region.Framework.Scenes
                         return sp.AbsolutePosition;
                 }
 
+                // use root prim's group position. Physics may have updated it
+                if (ParentGroup.RootPart != this)
+                    m_groupPosition = ParentGroup.RootPart.GroupPosition;
                 return m_groupPosition;
             }
             set
             {
                 m_groupPosition = value;
-
                 PhysicsActor actor = PhysActor;
-                if (actor != null)
+                if (actor != null && ParentGroup.Scene.PhysicsScene != null)
                 {
                     try
                     {
@@ -750,16 +800,6 @@ namespace OpenSim.Region.Framework.Scenes
                         m_log.ErrorFormat("[SCENEOBJECTPART]: GROUP POSITION. {0}", e);
                     }
                 }
-                
-                // TODO if we decide to do sitting in a more SL compatible way (multiple avatars per prim), this has to be fixed, too
-                if (SitTargetAvatar != UUID.Zero)
-                {
-                    ScenePresence avatar;
-                    if (ParentGroup.Scene.TryGetScenePresence(SitTargetAvatar, out avatar))
-                    {
-                        avatar.ParentPosition = GetWorldPosition();
-                    }
-                }
             }
         }
 
@@ -768,7 +808,7 @@ namespace OpenSim.Region.Framework.Scenes
             get { return m_offsetPosition; }
             set
             {
-//                StoreUndoState();
+                Vector3 oldpos = m_offsetPosition;
                 m_offsetPosition = value;
 
                 if (ParentGroup != null && !ParentGroup.IsDeleted)
@@ -780,10 +820,25 @@ namespace OpenSim.Region.Framework.Scenes
                         actor.Orientation = GetWorldRotation();
 
                         // Tell the physics engines that this prim changed.
-                        if (ParentGroup.Scene != null)
+                        if (ParentGroup.Scene != null && ParentGroup.Scene.PhysicsScene != null)
                             ParentGroup.Scene.PhysicsScene.AddPhysicsActorTaint(actor);
                     }
+
+                    if (!m_parentGroup.m_dupeInProgress)
+                    {
+                        List<ScenePresence> avs = ParentGroup.GetLinkedAvatars();
+                        foreach (ScenePresence av in avs)
+                        {
+                            if (av.ParentID == m_localId)
+                            {
+                                Vector3 offset = (m_offsetPosition - oldpos);
+                                av.AbsolutePosition += offset;
+                                av.SendAvatarDataToAllAgents();
+                            }
+                        }
+                    }
                 }
+                TriggerScriptChangedEvent(Changed.POSITION);
             }
         }
 
@@ -834,7 +889,7 @@ namespace OpenSim.Region.Framework.Scenes
             
             set
             {
-                StoreUndoState();
+//                StoreUndoState();
                 m_rotationOffset = value;
 
                 PhysicsActor actor = PhysActor;
@@ -922,19 +977,36 @@ namespace OpenSim.Region.Framework.Scenes
             get
             {
                 PhysicsActor actor = PhysActor;
-                if ((actor != null) && actor.IsPhysical)
+                if ((actor != null) && actor.IsPhysical && ParentGroup.RootPart == this)
                 {
                     m_angularVelocity = actor.RotationalVelocity;
                 }
                 return m_angularVelocity;
             }
-            set { m_angularVelocity = value; }
+            set
+            {
+                m_angularVelocity = value;
+                PhysicsActor actor = PhysActor;
+                if ((actor != null) && actor.IsPhysical && ParentGroup.RootPart == this && VehicleType == (int)Vehicle.TYPE_NONE)
+                {
+                    actor.RotationalVelocity = m_angularVelocity;
+                }                       
+            }
         }
 
         /// <summary></summary>
         public Vector3 Acceleration
         {
-            get { return m_acceleration; }
+                        get 
+                        { 
+                PhysicsActor actor = PhysActor;
+                if (actor != null)
+                                {
+                                        m_acceleration = actor.Acceleration;
+                                }
+                                return m_acceleration;
+                        } 
+            
             set { m_acceleration = value; }
         }
 
@@ -1002,7 +1074,10 @@ namespace OpenSim.Region.Framework.Scenes
         public PrimitiveBaseShape Shape
         {
             get { return m_shape; }
-            set { m_shape = value;}
+            set
+            {
+                m_shape = value;
+            }
         }
 
         /// <summary>
@@ -1015,7 +1090,6 @@ namespace OpenSim.Region.Framework.Scenes
             {
                 if (m_shape != null)
                 {
-                    StoreUndoState();
 
                     m_shape.Scale = value;
 
@@ -1042,6 +1116,7 @@ namespace OpenSim.Region.Framework.Scenes
         }
 
         public UpdateRequired UpdateFlag { get; set; }
+        public bool UpdatePhysRequired { get; set; }
         
         /// <summary>
         /// Used for media on a prim.
@@ -1082,10 +1157,7 @@ namespace OpenSim.Region.Framework.Scenes
         {
             get
             {
-                if (ParentGroup.IsAttachment)
-                    return GroupPosition;
-
-                return m_offsetPosition + m_groupPosition;
+                return GroupPosition + (m_offsetPosition * ParentGroup.RootPart.RotationOffset);
             }
         }
 
@@ -1263,6 +1335,13 @@ namespace OpenSim.Region.Framework.Scenes
                 _flags = value; 
             }
         }
+        
+        [XmlIgnore]
+        public bool IsOccupied                          // KF If an av is sittingon this prim
+        {
+                get { return m_occupied; }
+                set { m_occupied = value; }
+        }
 
         /// <summary>
         /// ID of the avatar that is sat on us if we have a sit target.  If there is no such avatar then is UUID.Zero
@@ -1313,12 +1392,41 @@ namespace OpenSim.Region.Framework.Scenes
             set { m_sitAnimation = value; }
         }
 
+        public UUID invalidCollisionSoundUUID = new UUID("ffffffff-ffff-ffff-ffff-ffffffffffff");
+
+        // 0 for default collision sounds, -1 for script disabled sound 1 for script defined sound
+        // runtime thing.. do not persist
+        [XmlIgnore]
+        public sbyte CollisionSoundType
+        {
+            get
+            {
+                return m_collisionSoundType;
+            }
+            set
+            {
+                m_collisionSoundType = value;
+                if (value == -1)
+                    m_collisionSound = invalidCollisionSoundUUID;
+                else if (value == 0)
+                    m_collisionSound = UUID.Zero;
+            }
+        }
+
         public UUID CollisionSound
         {
             get { return m_collisionSound; }
             set
-            {
+            {           
                 m_collisionSound = value;
+
+                if (value == invalidCollisionSoundUUID)
+                    m_collisionSoundType = -1;
+                else if (value == UUID.Zero)
+                    m_collisionSoundType = 0;
+                else
+                    m_collisionSoundType = 1;
+
                 aggregateScriptEvents();
             }
         }
@@ -1329,6 +1437,125 @@ namespace OpenSim.Region.Framework.Scenes
             set { m_collisionSoundVolume = value; }
         }
 
+        public float Buoyancy
+        {
+            get
+            {
+                if (ParentGroup.RootPart == this)
+                    return m_buoyancy;
+
+                return ParentGroup.RootPart.Buoyancy;
+            }
+            set
+            {
+                if (ParentGroup != null && ParentGroup.RootPart != null && ParentGroup.RootPart != this)
+                {
+                    ParentGroup.RootPart.Buoyancy = value;
+                    return;
+                }
+                m_buoyancy = value;
+                if (PhysActor != null)
+                    PhysActor.Buoyancy = value;
+            }
+        }
+
+        public Vector3 Force
+        {
+            get
+            {
+                if (ParentGroup.RootPart == this)
+                    return m_force;
+
+                return ParentGroup.RootPart.Force;
+            }
+
+            set
+            {
+                if (ParentGroup != null && ParentGroup.RootPart != null && ParentGroup.RootPart != this)
+                {
+                    ParentGroup.RootPart.Force = value;
+                    return;
+                }
+                m_force = value;
+                if (PhysActor != null)
+                    PhysActor.Force = value;
+            }
+        }
+
+        public Vector3 Torque
+        {
+            get
+            {
+                if (ParentGroup.RootPart == this)
+                    return m_torque;
+                
+                return ParentGroup.RootPart.Torque;
+            }
+
+            set
+            {
+                if (ParentGroup != null && ParentGroup.RootPart != null && ParentGroup.RootPart != this)
+                {
+                    ParentGroup.RootPart.Torque = value;
+                    return;
+                }
+                m_torque = value;
+                if (PhysActor != null)
+                    PhysActor.Torque = value;
+            }
+        }
+
+        public byte Material
+        {
+            get { return (byte)m_material; }
+            set
+            {
+                if (value >= 0 && value <= (byte)SOPMaterialData.MaxMaterial)
+                {
+                    bool update = false;
+
+                    if (m_material != (Material)value)
+                    {
+                        update = true;
+                        m_material = (Material)value;
+                    }
+
+                    if (m_friction != SOPMaterialData.friction(m_material))
+                    {
+                        update = true;
+                        m_friction = SOPMaterialData.friction(m_material);
+                    }
+
+                    if (m_bounce != SOPMaterialData.bounce(m_material))
+                    {
+                        update = true;
+                        m_bounce = SOPMaterialData.bounce(m_material);
+                    }
+
+                    if (update)
+                    {
+                        if (PhysActor != null)
+                        {
+                            PhysActor.SetMaterial((int)value);
+                        }
+                        if(ParentGroup != null)
+                            ParentGroup.HasGroupChanged = true;
+                        ScheduleFullUpdateIfNone();
+                        UpdatePhysRequired = true;
+                    }
+                }
+            }
+        }
+
+        // not a propriety to move to methods place later
+        private bool HasMesh()
+        {
+            if (Shape != null && (Shape.SculptType == (byte)SculptType.Mesh))
+                return true;
+            return false;
+        }
+
+        // not a propriety to move to methods place later
         public byte DefaultPhysicsShapeType()
         {
             byte type;
@@ -1341,6 +1568,65 @@ namespace OpenSim.Region.Framework.Scenes
             return type;
         }
 
+        [XmlIgnore]
+        public bool UsesComplexCost
+        {
+            get
+            {
+                byte pst = PhysicsShapeType;
+                if(pst == (byte) PhysShapeType.none || pst == (byte) PhysShapeType.convex || HasMesh())
+                    return true;
+                return false;
+            }
+        }
+
+        [XmlIgnore]
+        public float PhysicsCost
+        {
+            get
+            {
+                if(PhysicsShapeType == (byte)PhysShapeType.none)
+                    return 0;
+
+                float cost = 0.1f;
+                if (PhysActor != null)
+                    cost = PhysActor.PhysicsCost;
+                else
+                    cost = 0.1f;
+
+                if ((Flags & PrimFlags.Physics) != 0)
+                    cost *= (1.0f + 0.01333f * Scale.LengthSquared()); // 0.01333 == 0.04/3
+                return cost;
+            }
+        }
+
+        [XmlIgnore]
+        public float StreamingCost
+        {
+            get
+            {
+                float cost;
+                if (PhysActor != null)
+                    cost = PhysActor.StreamCost;
+                else
+                    cost = 1.0f;
+                return 1.0f;
+            }
+        }
+
+        [XmlIgnore]
+        public float SimulationCost
+        {
+            get
+            {
+                // ignoring scripts. Don't like considering them for this
+                if((Flags & PrimFlags.Physics) != 0)
+                    return 1.0f;
+
+                return 0.5f;
+            }
+        }
+
         public byte PhysicsShapeType
         {
             get { return m_physicsShapeType; }
@@ -1374,23 +1660,100 @@ namespace OpenSim.Region.Framework.Scenes
                     }
                     else if (PhysActor == null)
                     {
-                        ApplyPhysics((uint)Flags, VolumeDetectActive);
+                        ApplyPhysics((uint)Flags, VolumeDetectActive, false);
+                        UpdatePhysicsSubscribedEvents();
                     }
                     else
                     {
-                        // TODO: Update physics actor
+                        PhysActor.PhysicsShapeType = m_physicsShapeType;
+//                        if (Shape.SculptEntry)
+//                            CheckSculptAndLoad();
                     }
 
                     if (ParentGroup != null)
                         ParentGroup.HasGroupChanged = true;
                 }
+
+                if (m_physicsShapeType != value)
+                {
+                    UpdatePhysRequired = true;
+                }
+            }
+        }
+
+        public float Density // in kg/m^3
+        {
+            get { return m_density; }
+            set
+            {
+                if (value >=1 && value <= 22587.0)
+                {
+                    m_density = value;
+                    UpdatePhysRequired = true;
+                }
+
+                ScheduleFullUpdateIfNone();
+
+                if (ParentGroup != null)
+                    ParentGroup.HasGroupChanged = true;
+            }
+        }
+
+        public float GravityModifier
+        {
+            get { return m_gravitymod; }
+            set
+            {
+                if( value >= -1 && value <=28.0f)
+                {
+                    m_gravitymod = value;
+                    UpdatePhysRequired = true;
+                }
+
+                ScheduleFullUpdateIfNone();
+
+                if (ParentGroup != null)
+                    ParentGroup.HasGroupChanged = true;
+
+            }
+        }
+
+        public float Friction
+        {
+            get { return m_friction; }
+            set
+            {
+                if (value >= 0 && value <= 255.0f)
+                {
+                    m_friction = value;
+                    UpdatePhysRequired = true;
+                }
+
+                ScheduleFullUpdateIfNone();
+
+                if (ParentGroup != null)
+                    ParentGroup.HasGroupChanged = true;
+            }
+        }
+
+        public float Restitution
+        {
+            get { return m_bounce; }
+            set
+            {
+                if (value >= 0 && value <= 1.0f)
+                {
+                    m_bounce = value;
+                    UpdatePhysRequired = true;
+                }
+
+                ScheduleFullUpdateIfNone();
+
+                if (ParentGroup != null)
+                    ParentGroup.HasGroupChanged = true;
             }
         }
 
-        public float Density { get; set; }
-        public float GravityModifier { get; set; }
-        public float Friction { get; set; }
-        public float Restitution { get; set; }
 
         #endregion Public Properties with only Get
 
@@ -1537,6 +1900,61 @@ namespace OpenSim.Region.Framework.Scenes
             }
         }
 
+        //      SetVelocity for LSL llSetVelocity..  may need revision if having other uses in future
+        public void SetVelocity(Vector3 pVel, bool localGlobalTF)
+        {
+            if (ParentGroup == null || ParentGroup.IsDeleted)
+                return;
+
+            if (ParentGroup.IsAttachment)
+                return;                         // don't work on attachments (for now ??)
+
+            SceneObjectPart root = ParentGroup.RootPart;
+
+            if (root.VehicleType != (int)Vehicle.TYPE_NONE) // don't mess with vehicles
+                return;
+
+            PhysicsActor pa = root.PhysActor;
+
+            if (pa == null || !pa.IsPhysical)
+                return;
+
+            if (localGlobalTF)
+            {
+                pVel = pVel * GetWorldRotation();
+            }
+
+            ParentGroup.Velocity = pVel;
+        }
+
+        //      SetAngularVelocity for LSL llSetAngularVelocity..  may need revision if having other uses in future
+        public void SetAngularVelocity(Vector3 pAngVel, bool localGlobalTF)
+        {
+            if (ParentGroup == null || ParentGroup.IsDeleted)
+                return;
+
+            if (ParentGroup.IsAttachment)
+                return;                         // don't work on attachments (for now ??)
+
+            SceneObjectPart root = ParentGroup.RootPart;
+
+            if (root.VehicleType != (int)Vehicle.TYPE_NONE) // don't mess with vehicles
+                return;
+
+            PhysicsActor pa = root.PhysActor;
+
+            if (pa == null || !pa.IsPhysical)
+                return;
+
+            if (localGlobalTF)
+            {
+                pAngVel = pAngVel * GetWorldRotation();
+            }
+
+            root.AngularVelocity = pAngVel;
+        }
+        
+
         /// <summary>
         /// hook to the physics scene to apply angular impulse
         /// This is sent up to the group, which then finds the root prim
@@ -1557,7 +1975,7 @@ namespace OpenSim.Region.Framework.Scenes
                 impulse = newimpulse;
             }
 
-            ParentGroup.applyAngularImpulse(impulse);
+            ParentGroup.ApplyAngularImpulse(impulse);
         }
 
         /// <summary>
@@ -1567,20 +1985,24 @@ namespace OpenSim.Region.Framework.Scenes
         /// </summary>
         /// <param name="impulsei">Vector force</param>
         /// <param name="localGlobalTF">true for the local frame, false for the global frame</param>
-        public void SetAngularImpulse(Vector3 impulsei, bool localGlobalTF)
+        
+        // this is actualy Set Torque.. keeping naming so not to edit lslapi also
+        public void SetAngularImpulse(Vector3 torquei, bool localGlobalTF)
         {
-            Vector3 impulse = impulsei;
+            Vector3 torque = torquei;
 
             if (localGlobalTF)
             {
+/*
                 Quaternion grot = GetWorldRotation();
                 Quaternion AXgrot = grot;
                 Vector3 AXimpulsei = impulsei;
                 Vector3 newimpulse = AXimpulsei * AXgrot;
-                impulse = newimpulse;
+ */
+                torque *= GetWorldRotation();
             }
 
-            ParentGroup.setAngularImpulse(impulse);
+            Torque = torque;
         }
 
         /// <summary>
@@ -1588,16 +2010,23 @@ namespace OpenSim.Region.Framework.Scenes
         /// </summary>
         /// <param name="rootObjectFlags"></param>
         /// <param name="VolumeDetectActive"></param>
-        public void ApplyPhysics(uint rootObjectFlags, bool VolumeDetectActive)
+        /// <param name="building"></param>
+
+                public void ApplyPhysics(uint _ObjectFlags, bool _VolumeDetectActive, bool building)
         {
+            VolumeDetectActive = _VolumeDetectActive;
+
             if (!ParentGroup.Scene.CollidablePrims)
                 return;
 
             if (PhysicsShapeType == (byte)PhysShapeType.none)
                 return;
 
-            bool isPhysical = (rootObjectFlags & (uint) PrimFlags.Physics) != 0;
-            bool isPhantom = (rootObjectFlags & (uint) PrimFlags.Phantom) != 0;
+            bool isPhysical = (_ObjectFlags & (uint) PrimFlags.Physics) != 0;
+            bool isPhantom = (_ObjectFlags & (uint)PrimFlags.Phantom) != 0;
+
+            if (_VolumeDetectActive)
+                isPhantom = true;
 
             if (IsJoint())
             {
@@ -1605,22 +2034,14 @@ namespace OpenSim.Region.Framework.Scenes
             }
             else
             {
-                // Special case for VolumeDetection: If VolumeDetection is set, the phantom flag is locally ignored
-                if (VolumeDetectActive)
-                    isPhantom = false;
-
-                // The only time the physics scene shouldn't know about the prim is if it's phantom or an attachment, which is phantom by definition
-                // or flexible
-                if (!isPhantom && !ParentGroup.IsAttachment && !(Shape.PathCurve == (byte)Extrusion.Flexible))
+                if ((!isPhantom || isPhysical || _VolumeDetectActive) && !ParentGroup.IsAttachment
+                                                && !(Shape.PathCurve == (byte)Extrusion.Flexible))
                 {
-                    // Added clarification..   since A rigid body is an object that you can kick around, etc.
-                    bool rigidBody = isPhysical && !isPhantom;
-
-                    PhysicsActor pa = AddToPhysics(rigidBody);
-
-                    if (pa != null)
-                        pa.SetVolumeDetect(VolumeDetectActive ? 1 : 0);
+                    AddToPhysics(isPhysical, isPhantom, building, isPhysical);
+                    UpdatePhysicsSubscribedEvents(); // not sure if appliable here
                 }
+                else
+                    PhysActor = null; // just to be sure
             }
         }
 
@@ -1672,6 +2093,12 @@ namespace OpenSim.Region.Framework.Scenes
             dupe.Category = Category;
             dupe.m_rezzed = m_rezzed;
 
+            dupe.m_UndoRedo = null;
+            dupe.m_isSelected = false;
+
+            dupe.IgnoreUndoUpdate = false;
+            dupe.Undoing = false;
+
             dupe.m_inventory = new SceneObjectPartInventory(dupe);
             dupe.m_inventory.Items = (TaskInventoryDictionary)m_inventory.Items.Clone();
 
@@ -1687,6 +2114,7 @@ namespace OpenSim.Region.Framework.Scenes
 
             // Move afterwards ResetIDs as it clears the localID
             dupe.LocalId = localID;
+
             // This may be wrong...    it might have to be applied in SceneObjectGroup to the object that's being duplicated.
             dupe.LastOwnerID = OwnerID;
 
@@ -1694,6 +2122,9 @@ namespace OpenSim.Region.Framework.Scenes
             Array.Copy(Shape.ExtraParams, extraP, extraP.Length);
             dupe.Shape.ExtraParams = extraP;
 
+            // safeguard  actual copy is done in sog.copy
+            dupe.KeyframeMotion = null;
+
             dupe.DynAttrs.CopyFrom(DynAttrs);
             
             if (userExposed)
@@ -1707,8 +2138,12 @@ namespace OpenSim.Region.Framework.Scenes
 */                
                 bool UsePhysics = ((dupe.Flags & PrimFlags.Physics) != 0);
                 dupe.DoPhysicsPropertyUpdate(UsePhysics, true);
+//                dupe.UpdatePhysicsSubscribedEvents();  // not sure...
             }
             
+            if (dupe.PhysActor != null)
+                dupe.PhysActor.LocalID = localID;
+
             ParentGroup.Scene.EventManager.TriggerOnSceneObjectPartCopy(dupe, this, userExposed);
 
 //            m_log.DebugFormat("[SCENE OBJECT PART]: Clone of {0} {1} finished", Name, UUID);
@@ -1727,10 +2162,10 @@ namespace OpenSim.Region.Framework.Scenes
         {
             if (asset != null)
                 SculptTextureCallback(asset);
-            else
-                m_log.WarnFormat(
-                    "[SCENE OBJECT PART]: Part {0} {1} requested mesh/sculpt data for asset id {2} from asset service but received no data",
-                    Name, UUID, id);
+//            else
+//                m_log.WarnFormat(
+//                    "[SCENE OBJECT PART]: Part {0} {1} requested mesh/sculpt data for asset id {2} from asset service but received no data",
+//                    Name, UUID, id);
         }
 */
         /// <summary>
@@ -1829,6 +2264,7 @@ namespace OpenSim.Region.Framework.Scenes
 
         /// <summary>
         /// Do a physics propery update for this part.
+        /// now also updates phantom and volume detector
         /// </summary>
         /// <param name="UsePhysics"></param>
         /// <param name="isNew"></param>
@@ -1854,61 +2290,69 @@ namespace OpenSim.Region.Framework.Scenes
                     {
                         if (pa.IsPhysical) // implies UsePhysics==false for this block
                         {
-                            if (!isNew)
+                            if (!isNew)  // implies UsePhysics==false for this block
+                            {
                                 ParentGroup.Scene.RemovePhysicalPrim(1);
 
-                            pa.OnRequestTerseUpdate -= PhysicsRequestingTerseUpdate;
-                            pa.OnOutOfBounds -= PhysicsOutOfBounds;
-                            pa.delink();
+                                Velocity = new Vector3(0, 0, 0);
+                                Acceleration = new Vector3(0, 0, 0);
+                                if (ParentGroup.RootPart == this)
+                                    AngularVelocity = new Vector3(0, 0, 0);
 
-                            if (ParentGroup.Scene.PhysicsScene.SupportsNINJAJoints && (!isNew))
-                            {
-                                // destroy all joints connected to this now deactivated body
-                                ParentGroup.Scene.PhysicsScene.RemoveAllJointsConnectedToActorThreadLocked(pa);
-                            }
+                                if (pa.Phantom && !VolumeDetectActive)
+                                {
+                                    RemoveFromPhysics();
+                                    return;
+                                }
 
-                            // stop client-side interpolation of all joint proxy objects that have just been deleted
-                            // this is done because RemoveAllJointsConnectedToActor invokes the OnJointDeactivated callback,
-                            // which stops client-side interpolation of deactivated joint proxy objects.
+                                pa.IsPhysical = UsePhysics;
+                                pa.OnRequestTerseUpdate -= PhysicsRequestingTerseUpdate;
+                                pa.OnOutOfBounds -= PhysicsOutOfBounds;
+                                pa.delink();
+                                if (ParentGroup.Scene.PhysicsScene.SupportsNINJAJoints)
+                                {
+                                    // destroy all joints connected to this now deactivated body
+                                    ParentGroup.Scene.PhysicsScene.RemoveAllJointsConnectedToActorThreadLocked(pa);
+                                }
+                            }
                         }
 
-                        if (!UsePhysics && !isNew)
-                        {
-                            // reset velocity to 0 on physics switch-off. Without that, the client thinks the
-                            // prim still has velocity and continues to interpolate its position along the old
-                            // velocity-vector.
-                            Velocity = new Vector3(0, 0, 0);
-                            Acceleration = new Vector3(0, 0, 0);
-                            AngularVelocity = new Vector3(0, 0, 0);
-                            //RotationalVelocity = new Vector3(0, 0, 0);
-                        }
+                        if (pa.IsPhysical != UsePhysics)
+                            pa.IsPhysical = UsePhysics;
 
-                        pa.IsPhysical = UsePhysics;
+                        if (UsePhysics)
+                        {
+                            if (ParentGroup.RootPart.KeyframeMotion != null)
+                                ParentGroup.RootPart.KeyframeMotion.Stop();
+                            ParentGroup.RootPart.KeyframeMotion = null;
+                            ParentGroup.Scene.AddPhysicalPrim(1);
 
-                        // If we're not what we're supposed to be in the physics scene, recreate ourselves.
-                        //m_parentGroup.Scene.PhysicsScene.RemovePrim(PhysActor);
-                        /// that's not wholesome.  Had to make Scene public
-                        //PhysActor = null;
+                            PhysActor.OnRequestTerseUpdate += PhysicsRequestingTerseUpdate;
+                            PhysActor.OnOutOfBounds += PhysicsOutOfBounds;
 
-                        if ((Flags & PrimFlags.Phantom) == 0)
-                        {
-                            if (UsePhysics)
+                            if (ParentID != 0 && ParentID != LocalId)
                             {
-                                ParentGroup.Scene.AddPhysicalPrim(1);
+                                PhysicsActor parentPa = ParentGroup.RootPart.PhysActor;
 
-                                pa.OnRequestTerseUpdate += PhysicsRequestingTerseUpdate;
-                                pa.OnOutOfBounds += PhysicsOutOfBounds;
-                                if (ParentID != 0 && ParentID != LocalId)
+                                if (parentPa != null)
                                 {
-                                    PhysicsActor parentPa = ParentGroup.RootPart.PhysActor;
-
-                                    if (parentPa != null)
-                                    {
-                                        pa.link(parentPa);
-                                    }
+                                    pa.link(parentPa);
                                 }
                             }
-                        }
+                        }                           
+                    }
+
+                    bool phan = ((Flags & PrimFlags.Phantom) != 0);
+                    if (pa.Phantom != phan)
+                        pa.Phantom = phan;
+
+// some engines dont' have this check still
+//                    if (VolumeDetectActive != pa.IsVolumeDtc)
+                    {
+                        if (VolumeDetectActive)
+                            pa.SetVolumeDetect(1);
+                        else
+                            pa.SetVolumeDetect(0);
                     }
 
                     // If this part is a sculpt then delay the physics update until we've asynchronously loaded the
@@ -2027,42 +2471,63 @@ namespace OpenSim.Region.Framework.Scenes
 
         public Vector3 GetGeometricCenter()
         {
+            // this is not real geometric center but a average of positions relative to root prim acording to
+            // http://wiki.secondlife.com/wiki/llGetGeometricCenter
+            // ignoring tortured prims details since sl also seems to ignore
+            // so no real use in doing it on physics
+            if (ParentGroup.IsDeleted)
+                return new Vector3(0, 0, 0);
+
+            return ParentGroup.GetGeometricCenter();
+        }
+
+        public float GetMass()
+        {
             PhysicsActor pa = PhysActor;
 
             if (pa != null)
-                return new Vector3(pa.GeometricCenter.X, pa.GeometricCenter.Y, pa.GeometricCenter.Z);
+                return pa.Mass;
             else
-                return new Vector3(0, 0, 0);
+                return 0;
         }
 
         public Vector3 GetCenterOfMass()
         {
+            if (ParentGroup.RootPart == this)
+            {
+                if (ParentGroup.IsDeleted)
+                    return AbsolutePosition;
+                return ParentGroup.GetCenterOfMass();
+            }
+
             PhysicsActor pa = PhysActor;
 
             if (pa != null)
-                return new Vector3(pa.CenterOfMass.X, pa.CenterOfMass.Y, pa.CenterOfMass.Z);
+            {
+                Vector3 tmp = pa.CenterOfMass;
+                return tmp;
+            }
             else
-                return new Vector3(0, 0, 0);
+                return AbsolutePosition;
         }
 
-        public float GetMass()
+        public Vector3 GetPartCenterOfMass()
         {
             PhysicsActor pa = PhysActor;
 
             if (pa != null)
-                return pa.Mass;
+            {
+                Vector3 tmp = pa.CenterOfMass;
+                return tmp;
+            }
             else
-                return 0;
+                return AbsolutePosition;
         }
 
+
         public Vector3 GetForce()
         {
-            PhysicsActor pa = PhysActor;
-
-            if (pa != null)
-                return pa.Force;
-            else
-                return Vector3.Zero;
+            return Force;
         }
 
         /// <summary>
@@ -2277,15 +2742,25 @@ namespace OpenSim.Region.Framework.Scenes
 
         private void SendLandCollisionEvent(scriptEvents ev, ScriptCollidingNotification notify)
         {
-            if ((ParentGroup.RootPart.ScriptEvents & ev) != 0)
-            {
-                ColliderArgs LandCollidingMessage = new ColliderArgs();
-                List<DetectedObject> colliding = new List<DetectedObject>();
-                    
-                colliding.Add(CreateDetObjectForGround());
-                LandCollidingMessage.Colliders = colliding;
+            bool sendToRoot = true;
+
+            ColliderArgs LandCollidingMessage = new ColliderArgs();
+            List<DetectedObject> colliding = new List<DetectedObject>();
+                
+            colliding.Add(CreateDetObjectForGround());
+            LandCollidingMessage.Colliders = colliding;
 
+            if (Inventory.ContainsScripts())
+            {
+                if (!PassCollisions)
+                    sendToRoot = false;
+            }
+            if ((ScriptEvents & ev) != 0)
                 notify(LocalId, LandCollidingMessage);
+
+            if ((ParentGroup.RootPart.ScriptEvents & ev) != 0 && sendToRoot)
+            {
+                notify(ParentGroup.RootPart.LocalId, LandCollidingMessage);
             }
         }
 
@@ -2301,57 +2776,120 @@ namespace OpenSim.Region.Framework.Scenes
             List<uint> endedColliders = new List<uint>();
             List<uint> startedColliders = new List<uint>();
 
-            // calculate things that started colliding this time
-            // and build up list of colliders this time
-            foreach (uint localid in collissionswith.Keys)
+            if (collissionswith.Count == 0)
             {
-                thisHitColliders.Add(localid);
-                if (!m_lastColliders.Contains(localid))
-                    startedColliders.Add(localid);
-            }
+                if (m_lastColliders.Count == 0)
+                    return; // nothing to do
 
-            // calculate things that ended colliding
-            foreach (uint localID in m_lastColliders)
-            {
-                if (!thisHitColliders.Contains(localID))
+                foreach (uint localID in m_lastColliders)
+                {
                     endedColliders.Add(localID);
+                }
+                m_lastColliders.Clear();
             }
 
-            //add the items that started colliding this time to the last colliders list.
-            foreach (uint localID in startedColliders)
-                m_lastColliders.Add(localID);
+            else
+            {
+                List<CollisionForSoundInfo> soundinfolist = new List<CollisionForSoundInfo>();
 
-            // remove things that ended colliding from the last colliders list
-            foreach (uint localID in endedColliders)
-                m_lastColliders.Remove(localID);
+                // calculate things that started colliding this time
+                // and build up list of colliders this time
+                if (!VolumeDetectActive && CollisionSoundType >= 0)
+                {
+                    CollisionForSoundInfo soundinfo;
+                    ContactPoint curcontact;
 
-            // play the sound.
-            if (startedColliders.Count > 0 && CollisionSound != UUID.Zero && CollisionSoundVolume > 0.0f)
-            {
-                ISoundModule soundModule = ParentGroup.Scene.RequestModuleInterface<ISoundModule>();
-                if (soundModule != null)
+                    foreach (uint id in collissionswith.Keys)
+                    {
+                        thisHitColliders.Add(id);
+                        if (!m_lastColliders.Contains(id))
+                        {
+                            startedColliders.Add(id);
+
+                            curcontact = collissionswith[id];
+                            if (Math.Abs(curcontact.RelativeSpeed) > 0.2)
+                            {
+                                soundinfo = new CollisionForSoundInfo();
+                                soundinfo.colliderID = id;
+                                soundinfo.position = curcontact.Position;
+                                soundinfo.relativeVel = curcontact.RelativeSpeed;
+                                soundinfolist.Add(soundinfo);
+                            }
+                        }
+                    }
+                }
+                else
                 {
-                    soundModule.SendSound(UUID, CollisionSound,
-                            CollisionSoundVolume, true, (byte)0, 0, false,
-                            false);
+                    foreach (uint id in collissionswith.Keys)
+                    {
+                        thisHitColliders.Add(id);
+                        if (!m_lastColliders.Contains(id))
+                            startedColliders.Add(id);
+                    }
+                }
+
+                // calculate things that ended colliding
+                foreach (uint localID in m_lastColliders)
+                {
+                    if (!thisHitColliders.Contains(localID))
+                        endedColliders.Add(localID);
                 }
+
+                //add the items that started colliding this time to the last colliders list.
+                foreach (uint localID in startedColliders)
+                    m_lastColliders.Add(localID);
+
+                // remove things that ended colliding from the last colliders list
+                foreach (uint localID in endedColliders)
+                    m_lastColliders.Remove(localID);
+
+                // play sounds.
+                if (soundinfolist.Count > 0)
+                    CollisionSounds.PartCollisionSound(this, soundinfolist);
             }
 
             SendCollisionEvent(scriptEvents.collision_start, startedColliders, ParentGroup.Scene.EventManager.TriggerScriptCollidingStart);
-            SendCollisionEvent(scriptEvents.collision      , m_lastColliders , ParentGroup.Scene.EventManager.TriggerScriptColliding);
+            if (!VolumeDetectActive)
+                SendCollisionEvent(scriptEvents.collision  , m_lastColliders , ParentGroup.Scene.EventManager.TriggerScriptColliding);
             SendCollisionEvent(scriptEvents.collision_end  , endedColliders  , ParentGroup.Scene.EventManager.TriggerScriptCollidingEnd);
 
             if (startedColliders.Contains(0))
-            {
-                if (m_lastColliders.Contains(0))
-                    SendLandCollisionEvent(scriptEvents.land_collision, ParentGroup.Scene.EventManager.TriggerScriptLandColliding);
-                else
-                    SendLandCollisionEvent(scriptEvents.land_collision_start, ParentGroup.Scene.EventManager.TriggerScriptLandCollidingStart);
-            }
+                SendLandCollisionEvent(scriptEvents.land_collision_start, ParentGroup.Scene.EventManager.TriggerScriptLandCollidingStart);
+            if (m_lastColliders.Contains(0))
+                SendLandCollisionEvent(scriptEvents.land_collision, ParentGroup.Scene.EventManager.TriggerScriptLandColliding);
             if (endedColliders.Contains(0))
                 SendLandCollisionEvent(scriptEvents.land_collision_end, ParentGroup.Scene.EventManager.TriggerScriptLandCollidingEnd);
         }
 
+        // The Collision sounds code calls this
+        public void SendCollisionSound(UUID soundID, double volume, Vector3 position)
+        {
+            if (soundID == UUID.Zero)
+                return;
+
+            ISoundModule soundModule = ParentGroup.Scene.RequestModuleInterface<ISoundModule>();
+            if (soundModule == null)
+                return;
+
+            if (volume > 1)
+                volume = 1;
+            if (volume < 0)
+                volume = 0;
+
+            int now = Util.EnvironmentTickCount();
+            if(Util.EnvironmentTickCountSubtract(now,LastColSoundSentTime) <200)
+                return;
+
+            LastColSoundSentTime = now;
+
+            UUID ownerID = OwnerID;
+            UUID objectID = ParentGroup.RootPart.UUID;
+            UUID parentID = ParentGroup.UUID;
+            ulong regionHandle = ParentGroup.Scene.RegionInfo.RegionHandle;
+
+            soundModule.TriggerSound(soundID, ownerID, objectID, parentID, volume, position, regionHandle, 0 );
+        }
+
         public void PhysicsOutOfBounds(Vector3 pos)
         {
             // Note: This is only being called on the root prim at this time.
@@ -2373,9 +2911,9 @@ namespace OpenSim.Region.Framework.Scenes
                 Vector3 newpos = new Vector3(pa.Position.GetBytes(), 0);
                 
                 if (ParentGroup.Scene.TestBorderCross(newpos, Cardinals.N)
-                    | ParentGroup.Scene.TestBorderCross(newpos, Cardinals.S)
-                    | ParentGroup.Scene.TestBorderCross(newpos, Cardinals.E)
-                    | ParentGroup.Scene.TestBorderCross(newpos, Cardinals.W))
+                    || ParentGroup.Scene.TestBorderCross(newpos, Cardinals.S)
+                    || ParentGroup.Scene.TestBorderCross(newpos, Cardinals.E)
+                    || ParentGroup.Scene.TestBorderCross(newpos, Cardinals.W))
                 {
                     ParentGroup.AbsolutePosition = newpos;
                     return;
@@ -2502,6 +3040,19 @@ namespace OpenSim.Region.Framework.Scenes
             APIDTarget = Quaternion.Identity;
         }
 
+
+
+        public void ScheduleFullUpdateIfNone()
+        {
+            if (ParentGroup == null)
+                return;
+
+// ???            ParentGroup.HasGroupChanged = true;
+
+            if (UpdateFlag != UpdateRequired.FULL)
+                ScheduleFullUpdate();
+        }
+
         /// <summary>
         /// Schedules this prim for a full update
         /// </summary>
@@ -2647,6 +3198,14 @@ namespace OpenSim.Region.Framework.Scenes
             if (ParentGroup == null)
                 return;
 
+            // Update the "last" values
+            m_lastPosition = OffsetPosition;
+            m_lastRotation = RotationOffset;
+            m_lastVelocity = Velocity;
+            m_lastAcceleration = Acceleration;
+            m_lastAngularVelocity = AngularVelocity;
+            m_lastUpdateSentTime = Environment.TickCount;
+
             ParentGroup.Scene.ForEachScenePresence(delegate(ScenePresence avatar)
             {
                 SendFullUpdate(avatar.ControllingClient);
@@ -2705,8 +3264,8 @@ namespace OpenSim.Region.Framework.Scenes
         {
             const float ROTATION_TOLERANCE = 0.01f;
             const float VELOCITY_TOLERANCE = 0.001f;
-            const float POSITION_TOLERANCE = 0.05f;
-            const int TIME_MS_TOLERANCE = 3000;
+            const float POSITION_TOLERANCE = 0.05f; // I don't like this, but I suppose it's necessary
+            const int TIME_MS_TOLERANCE = 200; //llSetPos has a 200ms delay. This should NOT be 3 seconds.
 
             switch (UpdateFlag)
             {
@@ -2720,17 +3279,10 @@ namespace OpenSim.Region.Framework.Scenes
                         Velocity.ApproxEquals(Vector3.Zero, VELOCITY_TOLERANCE) ||
                         !AngularVelocity.ApproxEquals(m_lastAngularVelocity, VELOCITY_TOLERANCE) ||
                         !OffsetPosition.ApproxEquals(m_lastPosition, POSITION_TOLERANCE) ||
-                        Environment.TickCount - m_lastTerseSent > TIME_MS_TOLERANCE)
+                        Environment.TickCount - m_lastUpdateSentTime > TIME_MS_TOLERANCE)
                     {
                         SendTerseUpdateToAllClients();
 
-                        // Update the "last" values
-                        m_lastPosition = OffsetPosition;
-                        m_lastRotation = RotationOffset;
-                        m_lastVelocity = Velocity;
-                        m_lastAcceleration = Acceleration;
-                        m_lastAngularVelocity = AngularVelocity;
-                        m_lastTerseSent = Environment.TickCount;
                     }
                     break;
                 }
@@ -2748,6 +3300,17 @@ namespace OpenSim.Region.Framework.Scenes
         /// </summary>
         public void SendTerseUpdateToAllClients()
         {
+            if (ParentGroup == null || ParentGroup.Scene == null)
+                return;
+
+            // Update the "last" values
+            m_lastPosition = OffsetPosition;
+            m_lastRotation = RotationOffset;
+            m_lastVelocity = Velocity;
+            m_lastAcceleration = Acceleration;
+            m_lastAngularVelocity = AngularVelocity;
+            m_lastUpdateSentTime = Environment.TickCount;
+
             ParentGroup.Scene.ForEachClient(delegate(IClientAPI client)
             {
                 SendTerseUpdateToClient(client);
@@ -2771,10 +3334,13 @@ namespace OpenSim.Region.Framework.Scenes
 
         public void SetBuoyancy(float fvalue)
         {
-            PhysicsActor pa = PhysActor;
-
-            if (pa != null)
-                pa.Buoyancy = fvalue;
+            Buoyancy = fvalue;
+/*            
+            if (PhysActor != null)
+            {
+                PhysActor.Buoyancy = fvalue;
+            }
+ */
         }
 
         public void SetDieAtEdge(bool p)
@@ -2790,47 +3356,111 @@ namespace OpenSim.Region.Framework.Scenes
             PhysicsActor pa = PhysActor;
 
             if (pa != null)
-                pa.FloatOnWater = floatYN == 1;
+                pa.FloatOnWater = (floatYN == 1);
         }
 
         public void SetForce(Vector3 force)
         {
-            PhysicsActor pa = PhysActor;
+            Force = force;
+        }
 
-            if (pa != null)
-                pa.Force = force;
+        public SOPVehicle VehicleParams
+        {
+            get
+            {
+                return m_vehicleParams;
+            }
+            set
+            {
+                m_vehicleParams = value;
+            }
+        }
+
+
+        public int VehicleType
+        {
+            get
+            {
+                if (m_vehicleParams == null)
+                    return (int)Vehicle.TYPE_NONE;
+                else
+                    return (int)m_vehicleParams.Type;
+            }
+            set
+            {
+                SetVehicleType(value);
+            }
         }
 
         public void SetVehicleType(int type)
         {
-            PhysicsActor pa = PhysActor;
+                m_vehicleParams = null;
+                
+                if (type == (int)Vehicle.TYPE_NONE)
+                {
+                    if (_parentID ==0 && PhysActor != null)
+                        PhysActor.VehicleType = (int)Vehicle.TYPE_NONE;
+                    return;
+                }
+                m_vehicleParams = new SOPVehicle();
+                m_vehicleParams.ProcessTypeChange((Vehicle)type);
+                {
+                    if (_parentID ==0 && PhysActor != null)
+                        PhysActor.VehicleType = type;
+                    return;
+                }
+        }
 
-            if (pa != null)
-                pa.VehicleType = type;
+        public void SetVehicleFlags(int param, bool remove)
+        {
+            if (m_vehicleParams == null)
+                return;
+
+            m_vehicleParams.ProcessVehicleFlags(param, remove);
+
+            if (_parentID ==0 && PhysActor != null)
+            {
+                PhysActor.VehicleFlags(param, remove);
+            }
         }
 
         public void SetVehicleFloatParam(int param, float value)
         {
-            PhysicsActor pa = PhysActor;
+            if (m_vehicleParams == null)
+                return;
 
-            if (pa != null)
-                pa.VehicleFloatParam(param, value);
+            m_vehicleParams.ProcessFloatVehicleParam((Vehicle)param, value);
+
+            if (_parentID == 0 && PhysActor != null)
+            {
+                PhysActor.VehicleFloatParam(param, value);
+            }
         }
 
         public void SetVehicleVectorParam(int param, Vector3 value)
         {
-            PhysicsActor pa = PhysActor;
+            if (m_vehicleParams == null)
+                return;
 
-            if (pa != null)
-                pa.VehicleVectorParam(param, value);
+            m_vehicleParams.ProcessVectorVehicleParam((Vehicle)param, value);
+
+            if (_parentID == 0 && PhysActor != null)
+            {
+                PhysActor.VehicleVectorParam(param, value);
+            }
         }
 
         public void SetVehicleRotationParam(int param, Quaternion rotation)
         {
-            PhysicsActor pa = PhysActor;
+            if (m_vehicleParams == null)
+                return;
 
-            if (pa != null)
-                pa.VehicleRotationParam(param, rotation);
+            m_vehicleParams.ProcessRotationVehicleParam((Vehicle)param, rotation);
+
+            if (_parentID == 0 && PhysActor != null)
+            {
+                PhysActor.VehicleRotationParam(param, rotation);
+            }
         }
 
         /// <summary>
@@ -3031,14 +3661,6 @@ namespace OpenSim.Region.Framework.Scenes
             hasProfileCut = hasDimple; // is it the same thing?
         }
         
-        public void SetVehicleFlags(int param, bool remove)
-        {
-            PhysicsActor pa = PhysActor;
-
-            if (pa != null)
-                pa.VehicleFlags(param, remove);
-        }
-
         public void SetGroup(UUID groupID, IClientAPI client)
         {
             // Scene.AddNewPrims() calls with client == null so can't use this.
@@ -3138,71 +3760,20 @@ namespace OpenSim.Region.Framework.Scenes
         {
             ParentGroup.stopMoveToTarget();
 
-            ParentGroup.ScheduleGroupForTerseUpdate();
+//            ParentGroup.ScheduleGroupForTerseUpdate();
             //ParentGroup.ScheduleGroupForFullUpdate();
         }
 
-        public void StoreUndoState()
-        {
-            StoreUndoState(false);
-        }
-
-        public void StoreUndoState(bool forGroup)
+        public void StoreUndoState(ObjectChangeType change)
         {
-            if (ParentGroup == null || ParentGroup.Scene == null)
-                return;
+            if (m_UndoRedo == null)
+                m_UndoRedo = new UndoRedoState(5);
 
-            if (Undoing)
+            lock (m_UndoRedo)
             {
-//                m_log.DebugFormat(
-//                    "[SCENE OBJECT PART]: Ignoring undo store for {0} {1} since already undoing", Name, LocalId);
-                return;
-            }
-
-            if (IgnoreUndoUpdate)
-            {
-//                    m_log.DebugFormat("[SCENE OBJECT PART]: Ignoring undo store for {0} {1}", Name, LocalId);
-                return;
-            }
-
-            lock (m_undo)
-            {
-                if (m_undo.Count > 0)
+                if (!Undoing && !IgnoreUndoUpdate && ParentGroup != null) // just to read better  - undo is in progress, or suspended
                 {
-                    UndoState last = m_undo[m_undo.Count - 1];
-                    if (last != null)
-                    {
-                        // TODO: May need to fix for group comparison
-                        if (last.Compare(this))
-                        {
-//                                        m_log.DebugFormat(
-//                                            "[SCENE OBJECT PART]: Not storing undo for {0} {1} since current state is same as last undo state, initial stack size {2}",
-//                                            Name, LocalId, m_undo.Count);
-
-                            return;
-                        }
-                    }
-                }
-
-//                                m_log.DebugFormat(
-//                                    "[SCENE OBJECT PART]: Storing undo state for {0} {1}, forGroup {2}, initial stack size {3}",
-//                                    Name, LocalId, forGroup, m_undo.Count);
-
-                if (ParentGroup.Scene.MaxUndoCount > 0)
-                {
-                    UndoState nUndo = new UndoState(this, forGroup);
-
-                    m_undo.Add(nUndo);
-
-                    if (m_undo.Count > ParentGroup.Scene.MaxUndoCount)
-                        m_undo.RemoveAt(0);
-
-                    if (m_redo.Count > 0)
-                        m_redo.Clear();
-
-//                                    m_log.DebugFormat(
-//                                        "[SCENE OBJECT PART]: Stored undo state for {0} {1}, forGroup {2}, stack size now {3}",
-//                                        Name, LocalId, forGroup, m_undo.Count);
+                    m_UndoRedo.StoreUndo(this, change);
                 }
             }
         }
@@ -3214,88 +3785,46 @@ namespace OpenSim.Region.Framework.Scenes
         {
             get
             {
-                lock (m_undo)
-                    return m_undo.Count;
+                if (m_UndoRedo == null)
+                    return 0;
+                return m_UndoRedo.Count;
             }
         }
 
         public void Undo()
         {
-            lock (m_undo)
-            {
-//                m_log.DebugFormat(
-//                    "[SCENE OBJECT PART]: Handling undo request for {0} {1}, stack size {2}",
-//                    Name, LocalId, m_undo.Count);
-
-                if (m_undo.Count > 0)
-                {
-                    UndoState goback = m_undo[m_undo.Count - 1];
-                    m_undo.RemoveAt(m_undo.Count - 1);
-
-                    UndoState nUndo = null;
-    
-                    if (ParentGroup.Scene.MaxUndoCount > 0)
-                    {
-                        nUndo = new UndoState(this, goback.ForGroup);
-                    }
-
-                    goback.PlaybackState(this);
-
-                    if (nUndo != null)
-                    {
-                        m_redo.Add(nUndo);
-
-                        if (m_redo.Count > ParentGroup.Scene.MaxUndoCount)
-                            m_redo.RemoveAt(0);
-                    }
-                }
+            if (m_UndoRedo == null || Undoing || ParentGroup == null)
+                return;
 
-//                m_log.DebugFormat(
-//                    "[SCENE OBJECT PART]: Handled undo request for {0} {1}, stack size now {2}",
-//                    Name, LocalId, m_undo.Count);
+            lock (m_UndoRedo)
+            {
+                Undoing = true;
+                m_UndoRedo.Undo(this);
+                Undoing = false;
             }
         }
 
         public void Redo()
         {
-            lock (m_undo)
-            {
-//                m_log.DebugFormat(
-//                    "[SCENE OBJECT PART]: Handling redo request for {0} {1}, stack size {2}",
-//                    Name, LocalId, m_redo.Count);
-
-                if (m_redo.Count > 0)
-                {
-                    UndoState gofwd = m_redo[m_redo.Count - 1];
-                    m_redo.RemoveAt(m_redo.Count - 1);
-
-                    if (ParentGroup.Scene.MaxUndoCount > 0)
-                    {
-                        UndoState nUndo = new UndoState(this, gofwd.ForGroup);
-
-                        m_undo.Add(nUndo);
-
-                        if (m_undo.Count > ParentGroup.Scene.MaxUndoCount)
-                            m_undo.RemoveAt(0);
-                    }
-
-                    gofwd.PlayfwdState(this);
+            if (m_UndoRedo == null || Undoing || ParentGroup == null)
+                return;
 
-//                m_log.DebugFormat(
-//                    "[SCENE OBJECT PART]: Handled redo request for {0} {1}, stack size now {2}",
-//                    Name, LocalId, m_redo.Count);
-                }
+            lock (m_UndoRedo)
+            {
+                Undoing = true;
+                m_UndoRedo.Redo(this);
+                Undoing = false;
             }
         }
 
         public void ClearUndoState()
         {
-//            m_log.DebugFormat("[SCENE OBJECT PART]: Clearing undo and redo stacks in {0} {1}", Name, LocalId);
+            if (m_UndoRedo == null || Undoing)
+                return;
 
-            lock (m_undo)
+            lock (m_UndoRedo)
             {
-                m_undo.Clear();
-                m_redo.Clear();
+                m_UndoRedo.Clear();
             }
         }
 
@@ -3846,7 +4375,7 @@ namespace OpenSim.Region.Framework.Scenes
                         if (god)
                         {
                             BaseMask = ApplyMask(BaseMask, set, mask);
-                            Inventory.ApplyGodPermissions(_baseMask);
+                            Inventory.ApplyGodPermissions(BaseMask);
                         }
 
                         break;
@@ -3865,7 +4394,7 @@ namespace OpenSim.Region.Framework.Scenes
                     case 16:
                         NextOwnerMask = ApplyMask(NextOwnerMask, set, mask) &
                                 baseMask;
-                        // Prevent the client from creating no mod, no copy
+                        // Prevent the client from creating no copy, no transfer
                         // objects
                         if ((NextOwnerMask & (uint)PermissionMask.Copy) == 0)
                             NextOwnerMask |= (uint)PermissionMask.Transfer;
@@ -3883,20 +4412,20 @@ namespace OpenSim.Region.Framework.Scenes
         {
             bool update = false;
 
-            if (BaseMask != source.BaseMask ||
-                OwnerMask != source.OwnerMask ||
-                GroupMask != source.GroupMask ||
-                EveryoneMask != source.EveryoneMask ||
-                NextOwnerMask != source.NextOwnerMask)
-                update = true;
+            uint prevOwnerMask = OwnerMask;
+            uint prevGroupMask = GroupMask;
+            uint prevEveryoneMask = EveryoneMask;
+            uint prevNextOwnerMask = NextOwnerMask;
 
-            BaseMask = source.BaseMask;
-            OwnerMask = source.OwnerMask;
-            GroupMask = source.GroupMask;
-            EveryoneMask = source.EveryoneMask;
-            NextOwnerMask = source.NextOwnerMask;
+            OwnerMask = source.OwnerMask & BaseMask;
+            GroupMask = source.GroupMask & BaseMask;
+            EveryoneMask = source.EveryoneMask & BaseMask;
+            NextOwnerMask = source.NextOwnerMask & BaseMask;
 
-            if (update)
+            if (OwnerMask != prevOwnerMask ||
+                GroupMask != prevGroupMask ||
+                EveryoneMask != prevEveryoneMask ||
+                NextOwnerMask != prevNextOwnerMask)
                 SendFullUpdateToAllClients();
         }
 
@@ -3947,6 +4476,7 @@ namespace OpenSim.Region.Framework.Scenes
             }
         }
 
+
         public void UpdateExtraPhysics(ExtraPhysicsData physdata)
         {
             if (physdata.PhysShapeType == PhysShapeType.invalid || ParentGroup == null)
@@ -3974,7 +4504,7 @@ namespace OpenSim.Region.Framework.Scenes
         /// <param name="SetTemporary"></param>
         /// <param name="SetPhantom"></param>
         /// <param name="SetVD"></param>
-        public void UpdatePrimFlags(bool UsePhysics, bool SetTemporary, bool SetPhantom, bool SetVD)
+        public void UpdatePrimFlags(bool UsePhysics, bool SetTemporary, bool SetPhantom, bool SetVD, bool building)
         {
             bool wasUsingPhysics = ((Flags & PrimFlags.Physics) != 0);
             bool wasTemporary = ((Flags & PrimFlags.TemporaryOnRez) != 0);
@@ -3984,215 +4514,230 @@ namespace OpenSim.Region.Framework.Scenes
             if ((UsePhysics == wasUsingPhysics) && (wasTemporary == SetTemporary) && (wasPhantom == SetPhantom) && (SetVD == wasVD))
                 return;
 
-            PhysicsActor pa = PhysActor;
-
-            // Special cases for VD. VD can only be called from a script 
-            // and can't be combined with changes to other states. So we can rely
-            // that...
-            // ... if VD is changed, all others are not.
-            // ... if one of the others is changed, VD is not.
-            if (SetVD) // VD is active, special logic applies
-            {
-                // State machine logic for VolumeDetect
-                // More logic below
-                bool phanReset = (SetPhantom != wasPhantom) && !SetPhantom;
-
-                if (phanReset) // Phantom changes from on to off switch VD off too
-                {
-                    SetVD = false;               // Switch it of for the course of this routine
-                    VolumeDetectActive = false; // and also permanently
-
-                    if (pa != null)
-                        pa.SetVolumeDetect(0);   // Let physics know about it too
-                }
-                else
-                {
-                    // If volumedetect is active we don't want phantom to be applied.
-                    // If this is a new call to VD out of the state "phantom"
-                    // this will also cause the prim to be visible to physics
-                    SetPhantom = false;
-                }
-            }
+            VolumeDetectActive = SetVD;
 
-            if (UsePhysics && IsJoint())
-            {
+            // volume detector implies phantom
+            if (VolumeDetectActive)
                 SetPhantom = true;
-            }
 
             if (UsePhysics)
-            {
                 AddFlag(PrimFlags.Physics);
-                if (!wasUsingPhysics)
-                {
-                    DoPhysicsPropertyUpdate(UsePhysics, false);
-                }
-            }
             else
-            {
                 RemFlag(PrimFlags.Physics);
-                if (wasUsingPhysics)
-                {
-                    DoPhysicsPropertyUpdate(UsePhysics, false);
-                }
-            }
 
-            if (SetPhantom
-                || ParentGroup.IsAttachment
-                || PhysicsShapeType == (byte)PhysShapeType.none
-                || (Shape.PathCurve == (byte)Extrusion.Flexible)) // note: this may have been changed above in the case of joints
-            {
+            if (SetPhantom)
                 AddFlag(PrimFlags.Phantom);
-
-                if (PhysActor != null)
-                {
-                    RemoveFromPhysics();
-                    pa = null;
-                }
-            }
-            else // Not phantom
-            {
+            else
                 RemFlag(PrimFlags.Phantom);
 
-                if (ParentGroup.Scene == null)
-                    return;
+            if (SetTemporary)
+                AddFlag(PrimFlags.TemporaryOnRez);
+            else
+                RemFlag(PrimFlags.TemporaryOnRez);
 
-                if (ParentGroup.Scene.CollidablePrims && pa == null)
-                {
-                    pa = AddToPhysics(UsePhysics);
 
-                    if (pa != null)
-                    {
-                        pa.SetMaterial(Material);
-                        DoPhysicsPropertyUpdate(UsePhysics, true);
-    
-                        if (
-                            ((AggregateScriptEvents & scriptEvents.collision) != 0) ||
-                            ((AggregateScriptEvents & scriptEvents.collision_end) != 0) ||
-                            ((AggregateScriptEvents & scriptEvents.collision_start) != 0) ||
-                            ((AggregateScriptEvents & scriptEvents.land_collision_start) != 0) ||
-                            ((AggregateScriptEvents & scriptEvents.land_collision) != 0) ||
-                            ((AggregateScriptEvents & scriptEvents.land_collision_end) != 0) ||
-                            ((ParentGroup.RootPart.AggregateScriptEvents & scriptEvents.collision) != 0) ||
-                            ((ParentGroup.RootPart.AggregateScriptEvents & scriptEvents.collision_end) != 0) ||
-                            ((ParentGroup.RootPart.AggregateScriptEvents & scriptEvents.collision_start) != 0) ||
-                            ((ParentGroup.RootPart.AggregateScriptEvents & scriptEvents.land_collision_start) != 0) ||
-                            ((ParentGroup.RootPart.AggregateScriptEvents & scriptEvents.land_collision) != 0) ||
-                            ((ParentGroup.RootPart.AggregateScriptEvents & scriptEvents.land_collision_end) != 0) ||
-                            (CollisionSound != UUID.Zero)
-                            )
-                        {
-                            pa.OnCollisionUpdate += PhysicsCollision;
-                            pa.SubscribeEvents(1000);
-                        }
-                    }
-                }
-                else // it already has a physical representation
-                {
-                    DoPhysicsPropertyUpdate(UsePhysics, false); // Update physical status. If it's phantom this will remove the prim
-                }
-            }
+            if (ParentGroup.Scene == null)
+                return;
 
-            if (SetVD)
+            PhysicsActor pa = PhysActor;
+
+            if (pa != null && building && pa.Building != building)
+                pa.Building = building;
+
+            if ((SetPhantom && !UsePhysics && !SetVD) ||  ParentGroup.IsAttachment || PhysicsShapeType == (byte)PhysShapeType.none
+                || (Shape.PathCurve == (byte)Extrusion.Flexible))
             {
-                // If the above logic worked (this is urgent candidate to unit tests!)
-                // we now have a physicsactor.
-                // Defensive programming calls for a check here.
-                // Better would be throwing an exception that could be catched by a unit test as the internal 
-                // logic should make sure, this Physactor is always here.
                 if (pa != null)
                 {
-                    pa.SetVolumeDetect(1);
-                    AddFlag(PrimFlags.Phantom); // We set this flag also if VD is active
-                    VolumeDetectActive = true;
+                    if(wasUsingPhysics)
+                        ParentGroup.Scene.RemovePhysicalPrim(1);
+                    RemoveFromPhysics();
                 }
+
+                Velocity = new Vector3(0, 0, 0);
+                Acceleration = new Vector3(0, 0, 0);
+                if (ParentGroup.RootPart == this)
+                    AngularVelocity = new Vector3(0, 0, 0);
             }
             else if (SetVD != wasVD)
             {
-                // Remove VolumeDetect in any case. Note, it's safe to call SetVolumeDetect as often as you like
-                // (mumbles, well, at least if you have infinte CPU powers :-))
-                if (pa != null)
-                    pa.SetVolumeDetect(0);
+                if (ParentGroup.Scene.CollidablePrims)
+                {
+                    if (pa == null)
+                    {
+                        AddToPhysics(UsePhysics, SetPhantom, building, false);
+                        pa = PhysActor;
+/*
+                        if (pa != null)
+                        {
+                            if (
+//                                ((AggregateScriptEvents & scriptEvents.collision) != 0) ||
+//                                ((AggregateScriptEvents & scriptEvents.collision_end) != 0) ||
+//                                ((AggregateScriptEvents & scriptEvents.collision_start) != 0) ||
+//                                ((AggregateScriptEvents & scriptEvents.land_collision_start) != 0) ||
+//                                ((AggregateScriptEvents & scriptEvents.land_collision) != 0) ||
+//                                ((AggregateScriptEvents & scriptEvents.land_collision_end) != 0) ||
+                                ((AggregateScriptEvents & PhysicsNeededSubsEvents) != 0) ||
+                                ((ParentGroup.RootPart.AggregateScriptEvents & PhysicsNeededSubsEvents) != 0) ||
+                                (CollisionSound != UUID.Zero)
+                                )
+                            {
+                                pa.OnCollisionUpdate += PhysicsCollision;
+                                pa.SubscribeEvents(1000);
+                            }
+                        }
+*/
+                    }
+                    else // it already has a physical representation
+                    {
+                        DoPhysicsPropertyUpdate(UsePhysics, false); // Update physical status.
+/* moved into DoPhysicsPropertyUpdate
+                        if(VolumeDetectActive)
+                            pa.SetVolumeDetect(1);
+                        else
+                            pa.SetVolumeDetect(0);
+*/
 
-                RemFlag(PrimFlags.Phantom);
-                VolumeDetectActive = false;
-            }
+                        if (pa.Building != building)
+                            pa.Building = building;
+                    }
 
-            if (SetTemporary)
-            {
-                AddFlag(PrimFlags.TemporaryOnRez);
-            }
-            else
-            {
-                RemFlag(PrimFlags.TemporaryOnRez);
-            }
+                    UpdatePhysicsSubscribedEvents();
+                }
+            }         
 
             //            m_log.Debug("Update:  PHY:" + UsePhysics.ToString() + ", T:" + IsTemporary.ToString() + ", PHA:" + IsPhantom.ToString() + " S:" + CastsShadows.ToString());
 
+           // and last in case we have a new actor and not building
+
             if (ParentGroup != null)
             {
                 ParentGroup.HasGroupChanged = true;
                 ScheduleFullUpdate();
             }
-
+            
 //            m_log.DebugFormat("[SCENE OBJECT PART]: Updated PrimFlags on {0} {1} to {2}", Name, LocalId, Flags);
         }
 
         /// <summary>
         /// Adds this part to the physics scene.
+        /// and sets the PhysActor property
         /// </summary>
-        /// <remarks>This method also sets the PhysActor property.</remarks>
-        /// <param name="rigidBody">Add this prim with a rigid body.</param>
-        /// <returns>
-        /// The physics actor.  null if there was a failure.
-        /// </returns>
-        private PhysicsActor AddToPhysics(bool rigidBody)
-        {
+        /// <param name="isPhysical">Add this prim as physical.</param>
+        /// <param name="isPhantom">Add this prim as phantom.</param>
+        /// <param name="building">tells physics to delay full construction of object</param>
+        /// <param name="applyDynamics">applies velocities, force and torque</param>
+        private void AddToPhysics(bool isPhysical, bool isPhantom, bool building, bool applyDynamics)
+        {          
             PhysicsActor pa;
 
+            Vector3 velocity = Velocity; 
+            Vector3 rotationalVelocity = AngularVelocity;;
+
             try
             {
                 pa = ParentGroup.Scene.PhysicsScene.AddPrimShape(
-                        string.Format("{0}/{1}", Name, UUID),
-                        Shape,
-                        AbsolutePosition,
-                        Scale,
-                        RotationOffset,
-                        rigidBody,
-                        m_localId);
+                                 string.Format("{0}/{1}", Name, UUID),
+                                 Shape,
+                                 AbsolutePosition,
+                                 Scale,
+                                 GetWorldRotation(),
+                                 isPhysical,
+                                 isPhantom,
+                                 PhysicsShapeType,
+                                 m_localId);
             }
             catch (Exception e)
             {
                 m_log.ErrorFormat("[SCENE]: caught exception meshing object {0}. Object set to phantom. e={1}", m_uuid, e);
                 pa = null;
             }
-
-            // FIXME: Ideally we wouldn't set the property here to reduce situations where threads changing physical
-            // properties can stop on each other.  However, DoPhysicsPropertyUpdate() currently relies on PhysActor
-            // being set.
-            PhysActor = pa;
-
-            // Basic Physics can also return null as well as an exception catch.
+          
             if (pa != null)
             {
                 pa.SOPName = this.Name; // save object into the PhysActor so ODE internals know the joint/body info
                 pa.SetMaterial(Material);
-                DoPhysicsPropertyUpdate(rigidBody, true);
+
+                if (VolumeDetectActive) // change if not the default only
+                    pa.SetVolumeDetect(1);
+
+                if (m_vehicleParams != null && LocalId == ParentGroup.RootPart.LocalId)
+                    m_vehicleParams.SetVehicle(pa);
+
+                // we are going to tell rest of code about physics so better have this here
+                PhysActor = pa;
+
+                //                DoPhysicsPropertyUpdate(isPhysical, true);
+                // lets expand it here just with what it really needs to do
+
+                if (isPhysical)
+                {
+                    if (ParentGroup.RootPart.KeyframeMotion != null)
+                        ParentGroup.RootPart.KeyframeMotion.Stop();
+                    ParentGroup.RootPart.KeyframeMotion = null;
+                    ParentGroup.Scene.AddPhysicalPrim(1);
+
+                    pa.OnRequestTerseUpdate += PhysicsRequestingTerseUpdate;
+                    pa.OnOutOfBounds += PhysicsOutOfBounds;
+
+                    if (ParentID != 0 && ParentID != LocalId)
+                    {
+                        PhysicsActor parentPa = ParentGroup.RootPart.PhysActor;
+
+                        if (parentPa != null)
+                        {
+                            pa.link(parentPa);
+                        }
+                    }
+                }
+
+                if (applyDynamics) 
+                    // do independent of isphysical so parameters get setted (at least some)                   
+                {
+                    Velocity = velocity;
+                    AngularVelocity = rotationalVelocity;
+//                    pa.Velocity = velocity;
+                    pa.RotationalVelocity = rotationalVelocity;
+
+                    // if not vehicle and root part apply force and torque
+                    if ((m_vehicleParams == null || m_vehicleParams.Type == Vehicle.TYPE_NONE)
+                            && LocalId == ParentGroup.RootPart.LocalId)
+                    {
+                        pa.Force = Force;
+                        pa.Torque = Torque;
+                    }
+                }
+
+//                if (Shape.SculptEntry)
+//                    CheckSculptAndLoad();
+//                else
+                    ParentGroup.Scene.PhysicsScene.AddPhysicsActorTaint(pa);
+
+                if (!building)
+                    pa.Building = false;
             }
 
-            return pa;
-        }
+            PhysActor = pa;
+    }
 
         /// <summary>
         /// This removes the part from the physics scene.
         /// </summary>
         /// <remarks>
         /// This isn't the same as turning off physical, since even without being physical the prim has a physics
-        /// representation for collision detection.  Rather, this would be used in situations such as making a prim
-        /// phantom.
+        /// representation for collision detection.
         /// </remarks>
         public void RemoveFromPhysics()
         {
-            ParentGroup.Scene.PhysicsScene.RemovePrim(PhysActor);
+            PhysicsActor pa = PhysActor;
+            if (pa != null)
+            {
+                pa.OnCollisionUpdate -= PhysicsCollision;
+                pa.OnRequestTerseUpdate -= PhysicsRequestingTerseUpdate;
+                pa.OnOutOfBounds -= PhysicsOutOfBounds;
+
+                ParentGroup.Scene.PhysicsScene.RemovePrim(pa);
+            }
             PhysActor = null;
         }
 
@@ -4324,6 +4869,8 @@ namespace OpenSim.Region.Framework.Scenes
         {
 //            m_log.DebugFormat("Processing CheckSculptAndLoad for {0} {1}", Name, LocalId);
 
+            return;
+
             if (ParentGroup.IsDeleted)
                 return;
 
@@ -4404,6 +4951,44 @@ namespace OpenSim.Region.Framework.Scenes
             ScheduleFullUpdate();
         }
 
+
+        private void UpdatePhysicsSubscribedEvents()
+        {
+            PhysicsActor pa = PhysActor;
+            if (pa == null)
+                return;
+
+            pa.OnCollisionUpdate -= PhysicsCollision;
+
+            bool hassound = (!VolumeDetectActive && CollisionSoundType >= 0 && ((Flags & PrimFlags.Physics) != 0));
+
+            scriptEvents CombinedEvents = AggregateScriptEvents;
+
+            // merge with root part
+            if (ParentGroup != null && ParentGroup.RootPart != null)
+                CombinedEvents |= ParentGroup.RootPart.AggregateScriptEvents;
+
+            // submit to this part case
+            if (VolumeDetectActive)
+                CombinedEvents &= PhyscicsVolumeDtcSubsEvents;
+            else if ((Flags & PrimFlags.Phantom) != 0)
+                CombinedEvents &= PhyscicsPhantonSubsEvents;
+            else
+                CombinedEvents &= PhysicsNeededSubsEvents;
+
+            if (hassound || CombinedEvents != 0)
+            {
+                // subscribe to physics updates.
+                pa.OnCollisionUpdate += PhysicsCollision;
+                pa.SubscribeEvents(50); // 20 reports per second
+            }
+            else
+            {
+                pa.UnSubscribeEvents();
+            }
+        }
+
+
         public void aggregateScriptEvents()
         {
             if (ParentGroup == null || ParentGroup.RootPart == null)
@@ -4440,40 +5025,32 @@ namespace OpenSim.Region.Framework.Scenes
             {
                 objectflagupdate |= (uint) PrimFlags.AllowInventoryDrop;
             }
-
+/*
             PhysicsActor pa = PhysActor;
-
-            if (
-                ((AggregateScriptEvents & scriptEvents.collision) != 0) ||
-                ((AggregateScriptEvents & scriptEvents.collision_end) != 0) ||
-                ((AggregateScriptEvents & scriptEvents.collision_start) != 0) ||
-                ((AggregateScriptEvents & scriptEvents.land_collision_start) != 0) ||
-                ((AggregateScriptEvents & scriptEvents.land_collision) != 0) ||
-                ((AggregateScriptEvents & scriptEvents.land_collision_end) != 0) ||
-                ((ParentGroup.RootPart.AggregateScriptEvents & scriptEvents.collision) != 0) ||
-                ((ParentGroup.RootPart.AggregateScriptEvents & scriptEvents.collision_end) != 0) ||
-                ((ParentGroup.RootPart.AggregateScriptEvents & scriptEvents.collision_start) != 0) ||
-                ((ParentGroup.RootPart.AggregateScriptEvents & scriptEvents.land_collision_start) != 0) ||
-                ((ParentGroup.RootPart.AggregateScriptEvents & scriptEvents.land_collision) != 0) ||
-                ((ParentGroup.RootPart.AggregateScriptEvents & scriptEvents.land_collision_end) != 0) ||
-                (CollisionSound != UUID.Zero)
-                )
+            if (pa != null)
             {
-                // subscribe to physics updates.
-                if (pa != null)
+                if (
+//                    ((AggregateScriptEvents & scriptEvents.collision) != 0) ||
+//                    ((AggregateScriptEvents & scriptEvents.collision_end) != 0) ||
+//                    ((AggregateScriptEvents & scriptEvents.collision_start) != 0) ||
+//                    ((AggregateScriptEvents & scriptEvents.land_collision_start) != 0) ||
+//                    ((AggregateScriptEvents & scriptEvents.land_collision) != 0) ||
+//                    ((AggregateScriptEvents & scriptEvents.land_collision_end) != 0) ||
+                    ((AggregateScriptEvents & PhysicsNeededSubsEvents) != 0) || ((ParentGroup.RootPart.AggregateScriptEvents & PhysicsNeededSubsEvents) != 0) || (CollisionSound != UUID.Zero)
+                    )
                 {
+                    // subscribe to physics updates.
                     pa.OnCollisionUpdate += PhysicsCollision;
                     pa.SubscribeEvents(1000);
                 }
-            }
-            else
-            {
-                if (pa != null)
+                else
                 {
                     pa.UnSubscribeEvents();
                     pa.OnCollisionUpdate -= PhysicsCollision;
                 }
             }
+ */
+            UpdatePhysicsSubscribedEvents();
 
             //if ((GetEffectiveObjectFlags() & (uint)PrimFlags.Scripted) != 0)
             //{
@@ -4604,6 +5181,18 @@ namespace OpenSim.Region.Framework.Scenes
             return new Color4(color.R, color.G, color.B, (byte)(0xFF - color.A));
         }
 
+        public void ResetOwnerChangeFlag()
+        {
+            List<UUID> inv = Inventory.GetInventoryList();
+
+            foreach (UUID itemID in inv)
+            {
+                TaskInventoryItem item = Inventory.GetInventoryItem(itemID);
+                item.OwnerChanged = false;
+                Inventory.UpdateInventoryItem(item, false, false);
+            }
+        }
+
         /// <summary>
         /// Record an avatar sitting on this part.
         /// </summary>