Merge branch 'master' into careminster

Conflicts:
	OpenSim/Framework/Servers/HttpServer/PollServiceRequestManager.cs
	OpenSim/Region/ClientStack/Linden/UDP/LLClientView.cs
	OpenSim/Region/ClientStack/Linden/UDP/LLUDPServer.cs
	OpenSim/Region/Framework/Scenes/Scene.PacketHandlers.cs
	OpenSim/Region/Framework/Scenes/ScenePresence.cs
	OpenSim/Region/Physics/Manager/PhysicsActor.cs
	OpenSim/Region/Physics/Manager/PhysicsScene.cs

10 files changed, 297 insertions, 65 deletions

diff --git a/OpenSim/Region/Physics/BulletSPlugin/BSActors.cs b/OpenSim/Region/Physics/BulletSPlugin/BSActors.cs
index fff63e4..e0ccc50 100755
--- a/OpenSim/Region/Physics/BulletSPlugin/BSActors.cs
+++ b/OpenSim/Region/Physics/BulletSPlugin/BSActors.cs
@@ -69,7 +69,7 @@ public class BSActorCollection
     {
         lock (m_actors)
         {
-            Release();
+            ForEachActor(a => a.Dispose());
             m_actors.Clear();
         }
     }
@@ -98,10 +98,6 @@ public class BSActorCollection
     {
         ForEachActor(a => a.SetEnabled(enabl));
     }
-    public void Release()
-    {
-        ForEachActor(a => a.Dispose());
-    }
     public void Refresh()
     {
         ForEachActor(a => a.Refresh());
diff --git a/OpenSim/Region/Physics/BulletSPlugin/BSDynamics.cs b/OpenSim/Region/Physics/BulletSPlugin/BSDynamics.cs
index 0204967..82d7c44 100644
--- a/OpenSim/Region/Physics/BulletSPlugin/BSDynamics.cs
+++ b/OpenSim/Region/Physics/BulletSPlugin/BSDynamics.cs
@@ -45,7 +45,7 @@ namespace OpenSim.Region.Physics.BulletSPlugin
         private static string LogHeader = "[BULLETSIM VEHICLE]";
 
         // the prim this dynamic controller belongs to
-        private BSPrim ControllingPrim { get; set; }
+        private BSPrimLinkable ControllingPrim { get; set; }
 
         private bool m_haveRegisteredForSceneEvents;
 
@@ -128,9 +128,15 @@ namespace OpenSim.Region.Physics.BulletSPlugin
         public BSDynamics(BSScene myScene, BSPrim myPrim, string actorName)
             : base(myScene, myPrim, actorName)
         {
-            ControllingPrim = myPrim;
             Type = Vehicle.TYPE_NONE;
             m_haveRegisteredForSceneEvents = false;
+
+            ControllingPrim = myPrim as BSPrimLinkable;
+            if (ControllingPrim == null)
+            {
+                // THIS CANNOT HAPPEN!!
+            }
+            VDetailLog("{0},Creation", ControllingPrim.LocalID);
         }
 
         // Return 'true' if this vehicle is doing vehicle things
@@ -585,6 +591,8 @@ namespace OpenSim.Region.Physics.BulletSPlugin
                 // Friction affects are handled by this vehicle code
                 m_physicsScene.PE.SetFriction(ControllingPrim.PhysBody, BSParam.VehicleFriction);
                 m_physicsScene.PE.SetRestitution(ControllingPrim.PhysBody, BSParam.VehicleRestitution);
+                // ControllingPrim.Linkset.SetPhysicalFriction(BSParam.VehicleFriction);
+                // ControllingPrim.Linkset.SetPhysicalRestitution(BSParam.VehicleRestitution);
 
                 // Moderate angular movement introduced by Bullet.
                 // TODO: possibly set AngularFactor and LinearFactor for the type of vehicle.
@@ -595,17 +603,20 @@ namespace OpenSim.Region.Physics.BulletSPlugin
 
                 // Vehicles report collision events so we know when it's on the ground
                 m_physicsScene.PE.AddToCollisionFlags(ControllingPrim.PhysBody, CollisionFlags.BS_VEHICLE_COLLISIONS);
+                // ControllingPrim.Linkset.SetPhysicalCollisionFlags(CollisionFlags.BS_VEHICLE_COLLISIONS);
 
                 Vector3 inertia = m_physicsScene.PE.CalculateLocalInertia(ControllingPrim.PhysShape.physShapeInfo, m_vehicleMass);
                 ControllingPrim.Inertia = inertia * BSParam.VehicleInertiaFactor;
                 m_physicsScene.PE.SetMassProps(ControllingPrim.PhysBody, m_vehicleMass, ControllingPrim.Inertia);
                 m_physicsScene.PE.UpdateInertiaTensor(ControllingPrim.PhysBody);
+                // ControllingPrim.Linkset.ComputeLocalInertia(BSParam.VehicleInertiaFactor);
 
                 // Set the gravity for the vehicle depending on the buoyancy
                 // TODO: what should be done if prim and vehicle buoyancy differ?
                 m_VehicleGravity = ControllingPrim.ComputeGravity(m_VehicleBuoyancy);
                 // The actual vehicle gravity is set to zero in Bullet so we can do all the application of same.
                 m_physicsScene.PE.SetGravity(ControllingPrim.PhysBody, Vector3.Zero);
+                // ControllingPrim.Linkset.SetPhysicalGravity(Vector3.Zero);
 
                 VDetailLog("{0},BSDynamics.SetPhysicalParameters,mass={1},inert={2},vehGrav={3},aDamp={4},frict={5},rest={6},lFact={7},aFact={8}",
                         ControllingPrim.LocalID, m_vehicleMass, ControllingPrim.Inertia, m_VehicleGravity,
@@ -617,6 +628,7 @@ namespace OpenSim.Region.Physics.BulletSPlugin
             {
                 if (ControllingPrim.PhysBody.HasPhysicalBody)
                     m_physicsScene.PE.RemoveFromCollisionFlags(ControllingPrim.PhysBody, CollisionFlags.BS_VEHICLE_COLLISIONS);
+                // ControllingPrim.Linkset.RemoveFromPhysicalCollisionFlags(CollisionFlags.BS_VEHICLE_COLLISIONS);
             }
         }
 
@@ -629,6 +641,7 @@ namespace OpenSim.Region.Physics.BulletSPlugin
         // BSActor.Release()
         public override void Dispose()
         {
+            VDetailLog("{0},Dispose", ControllingPrim.LocalID);
             UnregisterForSceneEvents();
             Type = Vehicle.TYPE_NONE;
             Enabled = false;
@@ -1001,7 +1014,7 @@ namespace OpenSim.Region.Physics.BulletSPlugin
             else if (newVelocityLengthSq < 0.001f)
                 VehicleVelocity = Vector3.Zero;
 
-            VDetailLog("{0},  MoveLinear,done,isColl={1},newVel={2}", ControllingPrim.LocalID, ControllingPrim.IsColliding, VehicleVelocity );
+            VDetailLog("{0},  MoveLinear,done,isColl={1},newVel={2}", ControllingPrim.LocalID, ControllingPrim.HasSomeCollision, VehicleVelocity );
 
         } // end MoveLinear()
 
@@ -1029,8 +1042,8 @@ namespace OpenSim.Region.Physics.BulletSPlugin
             // Add this correction to the velocity to make it faster/slower.
             VehicleVelocity += linearMotorVelocityW;
 
-            VDetailLog("{0},  MoveLinear,velocity,origVelW={1},velV={2},correctV={3},correctW={4},newVelW={5},fricFact={6}",
-                        ControllingPrim.LocalID, origVelW, currentVelV, linearMotorCorrectionV,
+            VDetailLog("{0},  MoveLinear,velocity,origVelW={1},velV={2},tgt={3},correctV={4},correctW={5},newVelW={6},fricFact={7}",
+                        ControllingPrim.LocalID, origVelW, currentVelV, m_linearMotor.TargetValue, linearMotorCorrectionV,
                         linearMotorVelocityW, VehicleVelocity, frictionFactorV);
         }
 
@@ -1062,7 +1075,7 @@ namespace OpenSim.Region.Physics.BulletSPlugin
                 Vector3 linearDeflectionW = linearDeflectionV * VehicleOrientation;
 
                 // Optionally, if not colliding, don't effect world downward velocity. Let falling things fall.
-                if (BSParam.VehicleLinearDeflectionNotCollidingNoZ && !m_controllingPrim.IsColliding)
+                if (BSParam.VehicleLinearDeflectionNotCollidingNoZ && !m_controllingPrim.HasSomeCollision)
                 {
                     linearDeflectionW.Z = 0f;
                 }
@@ -1222,7 +1235,7 @@ namespace OpenSim.Region.Physics.BulletSPlugin
                 float targetHeight = Type == Vehicle.TYPE_BOAT ? GetWaterLevel(VehiclePosition) : GetTerrainHeight(VehiclePosition);
                 distanceAboveGround = VehiclePosition.Z - targetHeight;
                 // Not colliding if the vehicle is off the ground
-                if (!Prim.IsColliding)
+                if (!Prim.HasSomeCollision)
                 {
                     // downForce = new Vector3(0, 0, -distanceAboveGround / m_bankingTimescale);
                     VehicleVelocity += new Vector3(0, 0, -distanceAboveGround);
@@ -1233,12 +1246,12 @@ namespace OpenSim.Region.Physics.BulletSPlugin
                 //     be computed with a motor.
                 // TODO: add interaction with banking.
                 VDetailLog("{0},  MoveLinear,limitMotorUp,distAbove={1},colliding={2},ret={3}",
-                                Prim.LocalID, distanceAboveGround, Prim.IsColliding, ret);
+                                Prim.LocalID, distanceAboveGround, Prim.HasSomeCollision, ret);
                  */
 
                 // Another approach is to measure if we're going up. If going up and not colliding,
                 //     the vehicle is in the air.  Fix that by pushing down.
-                if (!ControllingPrim.IsColliding && VehicleVelocity.Z > 0.1)
+                if (!ControllingPrim.HasSomeCollision && VehicleVelocity.Z > 0.1)
                 {
                     // Get rid of any of the velocity vector that is pushing us up.
                     float upVelocity = VehicleVelocity.Z;
@@ -1260,7 +1273,7 @@ namespace OpenSim.Region.Physics.BulletSPlugin
                     }
                         */
                     VDetailLog("{0},  MoveLinear,limitMotorUp,collide={1},upVel={2},newVel={3}",
-                                    ControllingPrim.LocalID, ControllingPrim.IsColliding, upVelocity, VehicleVelocity);
+                                    ControllingPrim.LocalID, ControllingPrim.HasSomeCollision, upVelocity, VehicleVelocity);
                 }
             }
         }
@@ -1270,14 +1283,14 @@ namespace OpenSim.Region.Physics.BulletSPlugin
             Vector3 appliedGravity = m_VehicleGravity * m_vehicleMass;
 
             // Hack to reduce downward force if the vehicle is probably sitting on the ground
-            if (ControllingPrim.IsColliding && IsGroundVehicle)
+            if (ControllingPrim.HasSomeCollision && IsGroundVehicle)
                 appliedGravity *= BSParam.VehicleGroundGravityFudge;
 
             VehicleAddForce(appliedGravity);
 
             VDetailLog("{0},  MoveLinear,applyGravity,vehGrav={1},collid={2},fudge={3},mass={4},appliedForce={5}",
                             ControllingPrim.LocalID, m_VehicleGravity,
-                            ControllingPrim.IsColliding, BSParam.VehicleGroundGravityFudge, m_vehicleMass, appliedGravity);
+                            ControllingPrim.HasSomeCollision, BSParam.VehicleGroundGravityFudge, m_vehicleMass, appliedGravity);
         }
 
         // =======================================================================
diff --git a/OpenSim/Region/Physics/BulletSPlugin/BSLinkset.cs b/OpenSim/Region/Physics/BulletSPlugin/BSLinkset.cs
index ad8e10f..960c0b4 100755
--- a/OpenSim/Region/Physics/BulletSPlugin/BSLinkset.cs
+++ b/OpenSim/Region/Physics/BulletSPlugin/BSLinkset.cs
@@ -203,6 +203,33 @@ public abstract class BSLinkset
         return ret;
     }
 
+    // Called after a simulation step to post a collision with this object.
+    // Return 'true' if linkset processed the collision. 'false' says the linkset didn't have
+    //     anything to add for the collision and it should be passed through normal processing.
+    // Default processing for a linkset.
+    public virtual bool HandleCollide(uint collidingWith, BSPhysObject collidee,
+                                OMV.Vector3 contactPoint, OMV.Vector3 contactNormal, float pentrationDepth)
+    {
+        bool ret = false;
+
+        // prims in the same linkset cannot collide with each other
+        BSPrimLinkable convCollidee = collidee as BSPrimLinkable;
+        if (convCollidee != null && (LinksetID == convCollidee.Linkset.LinksetID))
+        {
+            // By returning 'true', we tell the caller the collision has been 'handled' so it won't
+            //     do anything about this collision and thus, effectivily, ignoring the collision.
+            ret = true;
+        }
+        else
+        {
+            // Not a collision between members of the linkset. Must be a real collision.
+            // So the linkset root can know if there is a collision anywhere in the linkset.
+            LinksetRoot.SomeCollisionSimulationStep = m_physicsScene.SimulationStep;
+        }
+
+        return ret;
+    }
+
     // I am the root of a linkset and a new child is being added
     // Called while LinkActivity is locked.
     protected abstract void AddChildToLinkset(BSPrimLinkable child);
@@ -251,6 +278,73 @@ public abstract class BSLinkset
     public abstract bool RemoveDependencies(BSPrimLinkable child);
 
     // ================================================================
+    // Some physical setting happen to all members of the linkset
+    public virtual void SetPhysicalFriction(float friction)
+    {
+        ForEachMember((member) =>
+            {
+                if (member.PhysBody.HasPhysicalBody)
+                    m_physicsScene.PE.SetFriction(member.PhysBody, friction);
+                return false;   // 'false' says to continue looping
+            }
+        );
+    }
+    public virtual void SetPhysicalRestitution(float restitution)
+    {
+        ForEachMember((member) =>
+            {
+                if (member.PhysBody.HasPhysicalBody)
+                    m_physicsScene.PE.SetRestitution(member.PhysBody, restitution);
+                return false;   // 'false' says to continue looping
+            }
+        );
+    }
+    public virtual void SetPhysicalGravity(OMV.Vector3 gravity)
+    {
+        ForEachMember((member) =>
+            {
+                if (member.PhysBody.HasPhysicalBody)
+                    m_physicsScene.PE.SetGravity(member.PhysBody, gravity);
+                return false;   // 'false' says to continue looping
+            }
+        );
+    }
+    public virtual void ComputeLocalInertia(OMV.Vector3 inertiaFactor)
+    {
+        ForEachMember((member) =>
+            {
+                if (member.PhysBody.HasPhysicalBody)
+                {
+                    OMV.Vector3 inertia = m_physicsScene.PE.CalculateLocalInertia(member.PhysShape.physShapeInfo, member.Mass);
+                    member.Inertia = inertia * inertiaFactor;
+                    m_physicsScene.PE.SetMassProps(member.PhysBody, member.Mass, member.Inertia);
+                    m_physicsScene.PE.UpdateInertiaTensor(member.PhysBody);
+                }
+                return false;   // 'false' says to continue looping
+            }
+        );
+    }
+    public virtual void SetPhysicalCollisionFlags(CollisionFlags collFlags)
+    {
+        ForEachMember((member) =>
+            {
+                if (member.PhysBody.HasPhysicalBody)
+                    m_physicsScene.PE.SetCollisionFlags(member.PhysBody, collFlags);
+                return false;   // 'false' says to continue looping
+            }
+        );
+    }
+    public virtual void RemoveFromPhysicalCollisionFlags(CollisionFlags collFlags)
+    {
+        ForEachMember((member) =>
+            {
+                if (member.PhysBody.HasPhysicalBody)
+                    m_physicsScene.PE.RemoveFromCollisionFlags(member.PhysBody, collFlags);
+                return false;   // 'false' says to continue looping
+            }
+        );
+    }
+    // ================================================================
     protected virtual float ComputeLinksetMass()
     {
         float mass = LinksetRoot.RawMass;
@@ -311,6 +405,5 @@ public abstract class BSLinkset
         if (m_physicsScene.PhysicsLogging.Enabled)
             m_physicsScene.DetailLog(msg, args);
     }
-
 }
 }
diff --git a/OpenSim/Region/Physics/BulletSPlugin/BSLinksetCompound.cs b/OpenSim/Region/Physics/BulletSPlugin/BSLinksetCompound.cs
index 1d94142..33ae5a5 100755
--- a/OpenSim/Region/Physics/BulletSPlugin/BSLinksetCompound.cs
+++ b/OpenSim/Region/Physics/BulletSPlugin/BSLinksetCompound.cs
@@ -44,6 +44,42 @@ public sealed class BSLinksetCompound : BSLinkset
     {
     }
 
+    // ================================================================
+    // Changing the physical property of the linkset only needs to change the root
+    public override void SetPhysicalFriction(float friction)
+    {
+        if (LinksetRoot.PhysBody.HasPhysicalBody)
+            m_physicsScene.PE.SetFriction(LinksetRoot.PhysBody, friction);
+    }
+    public override void SetPhysicalRestitution(float restitution)
+    {
+        if (LinksetRoot.PhysBody.HasPhysicalBody)
+            m_physicsScene.PE.SetRestitution(LinksetRoot.PhysBody, restitution);
+    }
+    public override void SetPhysicalGravity(OMV.Vector3 gravity)
+    {
+        if (LinksetRoot.PhysBody.HasPhysicalBody)
+            m_physicsScene.PE.SetGravity(LinksetRoot.PhysBody, gravity);
+    }
+    public override void ComputeLocalInertia(OMV.Vector3 inertiaFactor)
+    {
+        OMV.Vector3 inertia = m_physicsScene.PE.CalculateLocalInertia(LinksetRoot.PhysShape.physShapeInfo, LinksetRoot.Mass);
+        LinksetRoot.Inertia = inertia * inertiaFactor;
+        m_physicsScene.PE.SetMassProps(LinksetRoot.PhysBody, LinksetRoot.Mass, LinksetRoot.Inertia);
+        m_physicsScene.PE.UpdateInertiaTensor(LinksetRoot.PhysBody);
+    }
+    public override void SetPhysicalCollisionFlags(CollisionFlags collFlags)
+    {
+        if (LinksetRoot.PhysBody.HasPhysicalBody)
+            m_physicsScene.PE.SetCollisionFlags(LinksetRoot.PhysBody, collFlags);
+    }
+    public override void RemoveFromPhysicalCollisionFlags(CollisionFlags collFlags)
+    {
+        if (LinksetRoot.PhysBody.HasPhysicalBody)
+            m_physicsScene.PE.RemoveFromCollisionFlags(LinksetRoot.PhysBody, collFlags);
+    }
+    // ================================================================
+
     // When physical properties are changed the linkset needs to recalculate
     //   its internal properties.
     public override void Refresh(BSPrimLinkable requestor)
@@ -59,6 +95,7 @@ public sealed class BSLinksetCompound : BSLinkset
     {
         DetailLog("{0},BSLinksetCompound.ScheduleRebuild,,rebuilding={1},hasChildren={2},actuallyScheduling={3}",
                             requestor.LocalID, Rebuilding, HasAnyChildren, (!Rebuilding && HasAnyChildren));
+
         // When rebuilding, it is possible to set properties that would normally require a rebuild.
         //    If already rebuilding, don't request another rebuild.
         //    If a linkset with just a root prim (simple non-linked prim) don't bother rebuilding.
diff --git a/OpenSim/Region/Physics/BulletSPlugin/BSLinksetConstraints.cs b/OpenSim/Region/Physics/BulletSPlugin/BSLinksetConstraints.cs
index a06a44d..f17d698 100755
--- a/OpenSim/Region/Physics/BulletSPlugin/BSLinksetConstraints.cs
+++ b/OpenSim/Region/Physics/BulletSPlugin/BSLinksetConstraints.cs
@@ -48,12 +48,22 @@ public sealed class BSLinksetConstraints : BSLinkset
     {
         base.Refresh(requestor);
 
-        if (HasAnyChildren && IsRoot(requestor))
+    }
+
+    private void ScheduleRebuild(BSPrimLinkable requestor)
+    {
+        DetailLog("{0},BSLinksetConstraint.ScheduleRebuild,,rebuilding={1},hasChildren={2},actuallyScheduling={3}",
+                            requestor.LocalID, Rebuilding, HasAnyChildren, (!Rebuilding && HasAnyChildren));
+
+        // When rebuilding, it is possible to set properties that would normally require a rebuild.
+        //    If already rebuilding, don't request another rebuild.
+        //    If a linkset with just a root prim (simple non-linked prim) don't bother rebuilding.
+        if (!Rebuilding && HasAnyChildren)
         {
             // Queue to happen after all the other taint processing
             m_physicsScene.PostTaintObject("BSLinksetContraints.Refresh", requestor.LocalID, delegate()
                 {
-                    if (HasAnyChildren && IsRoot(requestor))
+                    if (HasAnyChildren)
                         RecomputeLinksetConstraints();
                 });
         }
@@ -67,8 +77,14 @@ public sealed class BSLinksetConstraints : BSLinkset
     // Called at taint-time!
     public override bool MakeDynamic(BSPrimLinkable child)
     {
-        // What is done for each object in BSPrim is what we want.
-        return false;
+        bool ret = false;
+        DetailLog("{0},BSLinksetConstraints.MakeDynamic,call,IsRoot={1}", child.LocalID, IsRoot(child));
+        if (IsRoot(child))
+        {
+            // The root is going dynamic. Rebuild the linkset so parts and mass get computed properly.
+            ScheduleRebuild(LinksetRoot);
+        }
+        return ret;
     }
 
     // The object is going static (non-physical). Do any setup necessary for a static linkset.
@@ -78,8 +94,16 @@ public sealed class BSLinksetConstraints : BSLinkset
     // Called at taint-time!
     public override bool MakeStatic(BSPrimLinkable child)
     {
-        // What is done for each object in BSPrim is what we want.
-        return false;
+        bool ret = false;
+
+        DetailLog("{0},BSLinksetConstraint.MakeStatic,call,IsRoot={1}", child.LocalID, IsRoot(child));
+        child.ClearDisplacement();
+        if (IsRoot(child))
+        {
+            // Schedule a rebuild to verify that the root shape is set to the real shape.
+            ScheduleRebuild(LinksetRoot);
+        }
+        return ret;
     }
 
     // Called at taint-time!!
@@ -105,7 +129,7 @@ public sealed class BSLinksetConstraints : BSLinkset
             // Just undo all the constraints for this linkset. Rebuild at the end of the step.
             ret = PhysicallyUnlinkAllChildrenFromRoot(LinksetRoot);
             // Cause the constraints, et al to be rebuilt before the next simulation step.
-            Refresh(LinksetRoot);
+            ScheduleRebuild(LinksetRoot);
         }
         return ret;
     }
@@ -123,7 +147,7 @@ public sealed class BSLinksetConstraints : BSLinkset
             DetailLog("{0},BSLinksetConstraints.AddChildToLinkset,call,child={1}", LinksetRoot.LocalID, child.LocalID);
 
             // Cause constraints and assorted properties to be recomputed before the next simulation step.
-            Refresh(LinksetRoot);
+            ScheduleRebuild(LinksetRoot);
         }
         return;
     }
@@ -147,7 +171,7 @@ public sealed class BSLinksetConstraints : BSLinkset
                 PhysicallyUnlinkAChildFromRoot(rootx, childx);
             });
             // See that the linkset parameters are recomputed at the end of the taint time.
-            Refresh(LinksetRoot);
+            ScheduleRebuild(LinksetRoot);
         }
         else
         {
@@ -165,6 +189,7 @@ public sealed class BSLinksetConstraints : BSLinkset
         Refresh(rootPrim);
     }
 
+    // Create a static constraint between the two passed objects
     private BSConstraint BuildConstraint(BSPrimLinkable rootPrim, BSPrimLinkable childPrim)
     {
         // Zero motion for children so they don't interpolate
@@ -281,24 +306,39 @@ public sealed class BSLinksetConstraints : BSLinkset
         DetailLog("{0},BSLinksetConstraint.RecomputeLinksetConstraints,set,rBody={1},linksetMass={2}",
                             LinksetRoot.LocalID, LinksetRoot.PhysBody.AddrString, linksetMass);
 
-        foreach (BSPrimLinkable child in m_children)
+        try
         {
-            // A child in the linkset physically shows the mass of the whole linkset.
-            // This allows Bullet to apply enough force on the child to move the whole linkset.
-            // (Also do the mass stuff before recomputing the constraint so mass is not zero.)
-            child.UpdatePhysicalMassProperties(linksetMass, true);
+            Rebuilding = true;
 
-            BSConstraint constrain;
-            if (!m_physicsScene.Constraints.TryGetConstraint(LinksetRoot.PhysBody, child.PhysBody, out constrain))
+            // There is no reason to build all this physical stuff for a non-physical linkset.
+            if (!LinksetRoot.IsPhysicallyActive)
             {
-                // If constraint doesn't exist yet, create it.
-                constrain = BuildConstraint(LinksetRoot, child);
+                DetailLog("{0},BSLinksetConstraint.RecomputeLinksetCompound,notPhysical", LinksetRoot.LocalID);
+                return; // Note the 'finally' clause at the botton which will get executed.
             }
-            constrain.RecomputeConstraintVariables(linksetMass);
 
-            // PhysicsScene.PE.DumpConstraint(PhysicsScene.World, constrain.Constraint);    // DEBUG DEBUG
-        }
+            foreach (BSPrimLinkable child in m_children)
+            {
+                // A child in the linkset physically shows the mass of the whole linkset.
+                // This allows Bullet to apply enough force on the child to move the whole linkset.
+                // (Also do the mass stuff before recomputing the constraint so mass is not zero.)
+                child.UpdatePhysicalMassProperties(linksetMass, true);
+
+                BSConstraint constrain;
+                if (!m_physicsScene.Constraints.TryGetConstraint(LinksetRoot.PhysBody, child.PhysBody, out constrain))
+                {
+                    // If constraint doesn't exist yet, create it.
+                    constrain = BuildConstraint(LinksetRoot, child);
+                }
+                constrain.RecomputeConstraintVariables(linksetMass);
 
+                // PhysicsScene.PE.DumpConstraint(PhysicsScene.World, constrain.Constraint);    // DEBUG DEBUG
+            }
+        }
+        finally
+        {
+            Rebuilding = false;
+        }
     }
 }
 }
diff --git a/OpenSim/Region/Physics/BulletSPlugin/BSParam.cs b/OpenSim/Region/Physics/BulletSPlugin/BSParam.cs
index dcf1e83..0bdb5f1 100755
--- a/OpenSim/Region/Physics/BulletSPlugin/BSParam.cs
+++ b/OpenSim/Region/Physics/BulletSPlugin/BSParam.cs
@@ -461,8 +461,9 @@ public static class BSParam
             (s) => { return MaxAddForceMagnitude; },
             (s,v) => { MaxAddForceMagnitude = v; MaxAddForceMagnitudeSquared = v * v; } ),
         // Density is passed around as 100kg/m3. This scales that to 1kg/m3.
+        // Reduce by power of 100 because Bullet doesn't seem to handle objects with large mass very well
         new ParameterDefn<float>("DensityScaleFactor", "Conversion for simulator/viewer density (100kg/m3) to physical density (1kg/m3)",
-            0.01f ),
+            0.0001f ),
 
         new ParameterDefn<float>("PID_D", "Derivitive factor for motion smoothing",
             2200f ),
@@ -607,8 +608,9 @@ public static class BSParam
             0.0f ),
         new ParameterDefn<float>("VehicleRestitution", "Bouncyness factor for vehicles (0.0 - 1.0)",
             0.0f ),
+        // Turn off fudge with DensityScaleFactor = 0.0001.  Value used to be 0.2f;
         new ParameterDefn<float>("VehicleGroundGravityFudge", "Factor to multiply gravity if a ground vehicle is probably on the ground (0.0 - 1.0)",
-            0.2f ),
+            1.0f ),
         new ParameterDefn<float>("VehicleAngularBankingTimescaleFudge", "Factor to multiple angular banking timescale. Tune to increase realism.",
             60.0f ),
         new ParameterDefn<bool>("VehicleEnableLinearDeflection", "Turn on/off vehicle linear deflection effect",
@@ -701,7 +703,7 @@ public static class BSParam
             new ParameterDefn<float>("LinksetImplementation", "Type of linkset implementation (0=Constraint, 1=Compound, 2=Manual)",
             (float)BSLinkset.LinksetImplementation.Compound ),
             new ParameterDefn<bool>("LinksetOffsetCenterOfMass", "If 'true', compute linkset center-of-mass and offset linkset position to account for same",
-            false ),
+            true ),
             new ParameterDefn<bool>("LinkConstraintUseFrameOffset", "For linksets built with constraints, enable frame offsetFor linksets built with constraints, enable frame offset.",
             false ),
             new ParameterDefn<bool>("LinkConstraintEnableTransMotor", "Whether to enable translational motor on linkset constraints",
diff --git a/OpenSim/Region/Physics/BulletSPlugin/BSPhysObject.cs b/OpenSim/Region/Physics/BulletSPlugin/BSPhysObject.cs
index fc4545f..d34b797 100755
--- a/OpenSim/Region/Physics/BulletSPlugin/BSPhysObject.cs
+++ b/OpenSim/Region/Physics/BulletSPlugin/BSPhysObject.cs
@@ -353,6 +353,16 @@ public abstract class BSPhysObject : PhysicsActor
                 CollidingStep = BSScene.NotASimulationStep;
             }
     }
+    // Complex objects (like linksets) need to know if there is a collision on any part of
+    //    their shape. 'IsColliding' has an existing definition of reporting a collision on
+    //    only this specific prim or component of linksets.
+    // 'HasSomeCollision' is defined as reporting if there is a collision on any part of
+    //    the complex body that this prim is the root of.
+    public virtual bool HasSomeCollision
+    {
+        get { return IsColliding; }
+        set { IsColliding = value; }
+    }
     public override bool CollidingGround {
         get { return (CollidingGroundStep == PhysScene.SimulationStep); }
         set
@@ -386,6 +396,7 @@ public abstract class BSPhysObject : PhysicsActor
     // Return 'true' if a collision was processed and should be sent up.
     // Return 'false' if this object is not enabled/subscribed/appropriate for or has already seen this collision.
     // Called at taint time from within the Step() function
+    public delegate bool CollideCall(uint collidingWith, BSPhysObject collidee, OMV.Vector3 contactPoint, OMV.Vector3 contactNormal, float pentrationDepth);
     public virtual bool Collide(uint collidingWith, BSPhysObject collidee,
                     OMV.Vector3 contactPoint, OMV.Vector3 contactNormal, float pentrationDepth)
     {
diff --git a/OpenSim/Region/Physics/BulletSPlugin/BSPrim.cs b/OpenSim/Region/Physics/BulletSPlugin/BSPrim.cs
index d43448e..e92a1d2 100644
--- a/OpenSim/Region/Physics/BulletSPlugin/BSPrim.cs
+++ b/OpenSim/Region/Physics/BulletSPlugin/BSPrim.cs
@@ -96,7 +96,7 @@ public class BSPrim : BSPhysObject
         _isVolumeDetect = false;
 
         // Add a dynamic vehicle to our set of actors that can move this prim.
-        PhysicalActors.Add(VehicleActorName, new BSDynamics(PhysScene, this, VehicleActorName));
+        // PhysicalActors.Add(VehicleActorName, new BSDynamics(PhysScene, this, VehicleActorName));
 
         _mass = CalculateMass();
 
@@ -440,8 +440,8 @@ public class BSPrim : BSPhysObject
                 Gravity = ComputeGravity(Buoyancy);
                 PhysScene.PE.SetGravity(PhysBody, Gravity);
 
-                OMV.Vector3 currentScale = PhysScene.PE.GetLocalScaling(PhysShape.physShapeInfo);   // DEBUG DEBUG
-                DetailLog("{0},BSPrim.UpdateMassProperties,currentScale{1},shape={2}", LocalID, currentScale, PhysShape.physShapeInfo);   // DEBUG DEBUG
+                // OMV.Vector3 currentScale = PhysScene.PE.GetLocalScaling(PhysShape.physShapeInfo);   // DEBUG DEBUG
+                // DetailLog("{0},BSPrim.UpdateMassProperties,currentScale{1},shape={2}", LocalID, currentScale, PhysShape.physShapeInfo);   // DEBUG DEBUG
 
                 Inertia = PhysScene.PE.CalculateLocalInertia(PhysShape.physShapeInfo, physMass);
                 PhysScene.PE.SetMassProps(PhysBody, physMass, Inertia);
@@ -495,9 +495,9 @@ public class BSPrim : BSPhysObject
         }
     }
 
-        // Find and return a handle to the current vehicle actor.
-        // Return 'null' if there is no vehicle actor.
-    public BSDynamics GetVehicleActor()
+    // Find and return a handle to the current vehicle actor.
+    // Return 'null' if there is no vehicle actor.
+    public BSDynamics GetVehicleActor(bool createIfNone)
     {
         BSDynamics ret = null;
         BSActor actor;
@@ -505,12 +505,21 @@ public class BSPrim : BSPhysObject
         {
             ret = actor as BSDynamics;
         }
+        else
+        {
+            if (createIfNone)
+            {
+                ret = new BSDynamics(PhysScene, this, VehicleActorName);
+                PhysicalActors.Add(ret.ActorName, ret);
+            }
+        }
         return ret;
     }
+
     public override int VehicleType {
         get {
             int ret = (int)Vehicle.TYPE_NONE;
-            BSDynamics vehicleActor = GetVehicleActor();
+            BSDynamics vehicleActor = GetVehicleActor(false /* createIfNone */);
             if (vehicleActor != null)
                 ret = (int)vehicleActor.Type;
             return ret;
@@ -524,11 +533,24 @@ public class BSPrim : BSPhysObject
                 //    change all the parameters. Like a plane changing to CAR when on the
                 //    ground. In this case, don't want to zero motion.
                 // ZeroMotion(true /* inTaintTime */);
-                BSDynamics vehicleActor = GetVehicleActor();
-                if (vehicleActor != null)
+                if (type == Vehicle.TYPE_NONE)
                 {
-                    vehicleActor.ProcessTypeChange(type);
-                    ActivateIfPhysical(false);
+                    // Vehicle type is 'none' so get rid of any actor that may have been allocated.
+                    BSDynamics vehicleActor = GetVehicleActor(false /* createIfNone */);
+                    if (vehicleActor != null)
+                    {
+                        PhysicalActors.RemoveAndRelease(vehicleActor.ActorName);
+                    }
+                }
+                else
+                {
+                    // Vehicle type is not 'none' so create an actor and set it running.
+                    BSDynamics vehicleActor = GetVehicleActor(true /* createIfNone */);
+                    if (vehicleActor != null)
+                    {
+                        vehicleActor.ProcessTypeChange(type);
+                        ActivateIfPhysical(false);
+                    }
                 }
             });
         }
@@ -537,7 +559,7 @@ public class BSPrim : BSPhysObject
     {
         PhysScene.TaintedObject("BSPrim.VehicleFloatParam", delegate()
         {
-            BSDynamics vehicleActor = GetVehicleActor();
+            BSDynamics vehicleActor = GetVehicleActor(true /* createIfNone */);
             if (vehicleActor != null)
             {
                 vehicleActor.ProcessFloatVehicleParam((Vehicle)param, value);
@@ -549,7 +571,7 @@ public class BSPrim : BSPhysObject
     {
         PhysScene.TaintedObject("BSPrim.VehicleVectorParam", delegate()
         {
-            BSDynamics vehicleActor = GetVehicleActor();
+            BSDynamics vehicleActor = GetVehicleActor(true /* createIfNone */);
             if (vehicleActor != null)
             {
                 vehicleActor.ProcessVectorVehicleParam((Vehicle)param, value);
@@ -561,7 +583,7 @@ public class BSPrim : BSPhysObject
     {
         PhysScene.TaintedObject("BSPrim.VehicleRotationParam", delegate()
         {
-            BSDynamics vehicleActor = GetVehicleActor();
+            BSDynamics vehicleActor = GetVehicleActor(true /* createIfNone */);
             if (vehicleActor != null)
             {
                 vehicleActor.ProcessRotationVehicleParam((Vehicle)param, rotation);
@@ -573,7 +595,7 @@ public class BSPrim : BSPhysObject
     {
         PhysScene.TaintedObject("BSPrim.VehicleFlags", delegate()
         {
-            BSDynamics vehicleActor = GetVehicleActor();
+            BSDynamics vehicleActor = GetVehicleActor(true /* createIfNone */);
             if (vehicleActor != null)
             {
                 vehicleActor.ProcessVehicleFlags(param, remove);
diff --git a/OpenSim/Region/Physics/BulletSPlugin/BSPrimLinkable.cs b/OpenSim/Region/Physics/BulletSPlugin/BSPrimLinkable.cs
index 1fbcfcc..2f392da 100755
--- a/OpenSim/Region/Physics/BulletSPlugin/BSPrimLinkable.cs
+++ b/OpenSim/Region/Physics/BulletSPlugin/BSPrimLinkable.cs
@@ -200,20 +200,38 @@ public class BSPrimLinkable : BSPrimDisplaced
     }
 
     // Called after a simulation step to post a collision with this object.
+    // This returns 'true' if the collision has been queued and the SendCollisions call must
+    //     be made at the end of the simulation step.
     public override bool Collide(uint collidingWith, BSPhysObject collidee,
                     OMV.Vector3 contactPoint, OMV.Vector3 contactNormal, float pentrationDepth)
     {
-        // prims in the same linkset cannot collide with each other
-        BSPrimLinkable convCollidee = collidee as BSPrimLinkable;
-        if (convCollidee != null && (this.Linkset.LinksetID == convCollidee.Linkset.LinksetID))
+        bool ret = false;
+        // Ask the linkset if it wants to handle the collision
+        if (!Linkset.HandleCollide(collidingWith, collidee, contactPoint, contactNormal, pentrationDepth))
         {
-            return false;
+            // The linkset didn't handle it so pass the collision through normal processing
+            ret = base.Collide(collidingWith, collidee, contactPoint, contactNormal, pentrationDepth);
         }
+        return ret;
+    }
 
-        // TODO: handle collisions of other objects with with children of linkset.
-        //    This is a problem for LinksetCompound since the children are packed into the root.
+    // A linkset reports any collision on any part of the linkset.
+    public long SomeCollisionSimulationStep = 0;
+    public override bool HasSomeCollision
+    {
+        get
+        {
+            return (SomeCollisionSimulationStep == PhysScene.SimulationStep) || base.IsColliding;
+        }
+        set
+        {
+            if (value)
+                SomeCollisionSimulationStep = PhysScene.SimulationStep;
+            else
+                SomeCollisionSimulationStep = 0;
 
-        return base.Collide(collidingWith, collidee, contactPoint, contactNormal, pentrationDepth);
+            base.HasSomeCollision = value;
+        }
     }
 }
 }
diff --git a/OpenSim/Region/Physics/BulletSPlugin/Tests/BasicVehicles.cs b/OpenSim/Region/Physics/BulletSPlugin/Tests/BasicVehicles.cs
index 48d3742..48e74eb 100755
--- a/OpenSim/Region/Physics/BulletSPlugin/Tests/BasicVehicles.cs
+++ b/OpenSim/Region/Physics/BulletSPlugin/Tests/BasicVehicles.cs
@@ -116,7 +116,7 @@ public class BasicVehicles : OpenSimTestCase
         //    Instead the appropriate values are set and calls are made just the parts of the
         //    controller we want to exercise. Stepping the physics engine then applies
         //    the actions of that one feature.
-        BSDynamics vehicleActor = TestVehicle.GetVehicleActor();
+        BSDynamics vehicleActor = TestVehicle.GetVehicleActor(true /* createIfNone */);
         if (vehicleActor != null)
         {
             vehicleActor.ProcessFloatVehicleParam(Vehicle.VERTICAL_ATTRACTION_EFFICIENCY, efficiency);