54 files changed, 7242 insertions, 3487 deletions

diff --git a/OpenSim/Region/Physics/BasicPhysicsPlugin/AssemblyInfo.cs b/OpenSim/Region/Physics/BasicPhysicsPlugin/AssemblyInfo.cs
index 6fd6f7e..ffcb01e 100644
--- a/OpenSim/Region/Physics/BasicPhysicsPlugin/AssemblyInfo.cs
+++ b/OpenSim/Region/Physics/BasicPhysicsPlugin/AssemblyInfo.cs
@@ -55,4 +55,4 @@ using System.Runtime.InteropServices;
 // You can specify all values by your own or you can build default build and revision
 // numbers with the '*' character (the default):
 
-[assembly : AssemblyVersion("0.7.6.*")]
+[assembly : AssemblyVersion("0.8.0.*")]
diff --git a/OpenSim/Region/Physics/BasicPhysicsPlugin/BasicPhysicsActor.cs b/OpenSim/Region/Physics/BasicPhysicsPlugin/BasicPhysicsActor.cs
index e43136a..0d17e0e 100644
--- a/OpenSim/Region/Physics/BasicPhysicsPlugin/BasicPhysicsActor.cs
+++ b/OpenSim/Region/Physics/BasicPhysicsPlugin/BasicPhysicsActor.cs
@@ -118,14 +118,7 @@ namespace OpenSim.Region.Physics.BasicPhysicsPlugin
 
         public override Vector3 Position { get; set; }
 
-        public override Vector3 Size
-        {
-            get { return _size; }
-            set {
-                  _size = value;
-                  _size.Z = _size.Z / 2.0f;
-                }
-        }
+        public override Vector3 Size { get; set; }
 
         public override PrimitiveBaseShape Shape
         {
diff --git a/OpenSim/Region/Physics/BulletSPlugin/BSAPIUnman.cs b/OpenSim/Region/Physics/BulletSPlugin/BSAPIUnman.cs
index 77ea3ed..3bd81d4 100755
--- a/OpenSim/Region/Physics/BulletSPlugin/BSAPIUnman.cs
+++ b/OpenSim/Region/Physics/BulletSPlugin/BSAPIUnman.cs
@@ -75,11 +75,11 @@ private sealed class BulletBodyUnman : BulletBody
 private sealed class BulletShapeUnman : BulletShape
 {
     public IntPtr ptr;
-    public BulletShapeUnman(IntPtr xx, BSPhysicsShapeType typ) 
+    public BulletShapeUnman(IntPtr xx, BSPhysicsShapeType typ)
         : base()
     {
         ptr = xx;
-        type = typ;
+        shapeType = typ;
     }
     public override bool HasPhysicalShape
     {
@@ -91,7 +91,7 @@ private sealed class BulletShapeUnman : BulletShape
     }
     public override BulletShape Clone()
     {
-        return new BulletShapeUnman(ptr, type);
+        return new BulletShapeUnman(ptr, shapeType);
     }
     public override bool ReferenceSame(BulletShape other)
     {
@@ -251,23 +251,52 @@ public override BulletShape CreateMeshShape(BulletWorld world,
                     BSPhysicsShapeType.SHAPE_MESH);
 }
 
+public override BulletShape CreateGImpactShape(BulletWorld world,
+                int indicesCount, int[] indices,
+                int verticesCount, float[] vertices)
+{
+    BulletWorldUnman worldu = world as BulletWorldUnman;
+    return new BulletShapeUnman(
+                    BSAPICPP.CreateGImpactShape2(worldu.ptr, indicesCount, indices, verticesCount, vertices),
+                    BSPhysicsShapeType.SHAPE_GIMPACT);
+}
+
 public override BulletShape CreateHullShape(BulletWorld world, int hullCount, float[] hulls)
 {
     BulletWorldUnman worldu = world as BulletWorldUnman;
     return new BulletShapeUnman(
-                    BSAPICPP.CreateHullShape2(worldu.ptr, hullCount, hulls), 
+                    BSAPICPP.CreateHullShape2(worldu.ptr, hullCount, hulls),
                     BSPhysicsShapeType.SHAPE_HULL);
 }
 
-public override BulletShape BuildHullShapeFromMesh(BulletWorld world, BulletShape meshShape)
+public override BulletShape BuildHullShapeFromMesh(BulletWorld world, BulletShape meshShape, HACDParams parms)
 {
     BulletWorldUnman worldu = world as BulletWorldUnman;
     BulletShapeUnman shapeu = meshShape as BulletShapeUnman;
     return new BulletShapeUnman(
-                    BSAPICPP.BuildHullShapeFromMesh2(worldu.ptr, shapeu.ptr),
+                    BSAPICPP.BuildHullShapeFromMesh2(worldu.ptr, shapeu.ptr, parms),
                     BSPhysicsShapeType.SHAPE_HULL);
 }
 
+public override BulletShape BuildConvexHullShapeFromMesh(BulletWorld world, BulletShape meshShape)
+{
+    BulletWorldUnman worldu = world as BulletWorldUnman;
+    BulletShapeUnman shapeu = meshShape as BulletShapeUnman;
+    return new BulletShapeUnman(
+                    BSAPICPP.BuildConvexHullShapeFromMesh2(worldu.ptr, shapeu.ptr),
+                    BSPhysicsShapeType.SHAPE_CONVEXHULL);
+}
+
+public override BulletShape CreateConvexHullShape(BulletWorld world,
+                int indicesCount, int[] indices,
+                int verticesCount, float[] vertices)
+{
+    BulletWorldUnman worldu = world as BulletWorldUnman;
+    return new BulletShapeUnman(
+                    BSAPICPP.CreateConvexHullShape2(worldu.ptr, indicesCount, indices, verticesCount, vertices),
+                    BSPhysicsShapeType.SHAPE_CONVEXHULL);
+}
+
 public override BulletShape BuildNativeShape(BulletWorld world, ShapeData shapeData)
 {
     BulletWorldUnman worldu = world as BulletWorldUnman;
@@ -356,7 +385,7 @@ public override BulletShape DuplicateCollisionShape(BulletWorld world, BulletSha
 {
     BulletWorldUnman worldu = world as BulletWorldUnman;
     BulletShapeUnman srcShapeu = srcShape as BulletShapeUnman;
-    return new BulletShapeUnman(BSAPICPP.DuplicateCollisionShape2(worldu.ptr, srcShapeu.ptr, id), srcShape.type);
+    return new BulletShapeUnman(BSAPICPP.DuplicateCollisionShape2(worldu.ptr, srcShapeu.ptr, id), srcShape.shapeType);
 }
 
 public override bool DeleteCollisionShape(BulletWorld world, BulletShape shape)
@@ -567,6 +596,60 @@ public override bool SetBreakingImpulseThreshold(BulletConstraint constrain, flo
     return BSAPICPP.SetBreakingImpulseThreshold2(constrainu.ptr, threshold);
 }
 
+public override bool HingeSetLimits(BulletConstraint constrain, float low, float high, float softness, float bias, float relaxation)
+{
+    BulletConstraintUnman constrainu = constrain as BulletConstraintUnman;
+    return BSAPICPP.HingeSetLimits2(constrainu.ptr, low, high, softness, bias, relaxation);
+}
+
+public override bool SpringEnable(BulletConstraint constrain, int index, float numericTrueFalse)
+{
+    BulletConstraintUnman constrainu = constrain as BulletConstraintUnman;
+    return BSAPICPP.ConstraintSpringEnable2(constrainu.ptr, index, numericTrueFalse);
+}
+
+public override bool SpringSetEquilibriumPoint(BulletConstraint constrain, int index, float equilibriumPoint)
+{
+    BulletConstraintUnman constrainu = constrain as BulletConstraintUnman;
+    return BSAPICPP.ConstraintSpringSetEquilibriumPoint2(constrainu.ptr, index, equilibriumPoint);
+}
+
+public override bool SpringSetStiffness(BulletConstraint constrain, int index, float stiffnesss)
+{
+    BulletConstraintUnman constrainu = constrain as BulletConstraintUnman;
+    return BSAPICPP.ConstraintSpringSetStiffness2(constrainu.ptr, index, stiffnesss);
+}
+
+public override bool SpringSetDamping(BulletConstraint constrain, int index, float damping)
+{
+    BulletConstraintUnman constrainu = constrain as BulletConstraintUnman;
+    return BSAPICPP.ConstraintSpringSetDamping2(constrainu.ptr, index, damping);
+}
+
+public override bool SliderSetLimits(BulletConstraint constrain, int lowerUpper, int linAng, float val)
+{
+    BulletConstraintUnman constrainu = constrain as BulletConstraintUnman;
+    return BSAPICPP.SliderSetLimits2(constrainu.ptr, lowerUpper, linAng, val);
+}
+
+public override bool SliderSet(BulletConstraint constrain, int softRestDamp, int dirLimOrtho, int linAng, float val)
+{
+    BulletConstraintUnman constrainu = constrain as BulletConstraintUnman;
+    return BSAPICPP.SliderSet2(constrainu.ptr, softRestDamp, dirLimOrtho, linAng, val);
+}
+
+public override bool SliderMotorEnable(BulletConstraint constrain, int linAng, float numericTrueFalse)
+{
+    BulletConstraintUnman constrainu = constrain as BulletConstraintUnman;
+    return BSAPICPP.SliderMotorEnable2(constrainu.ptr, linAng, numericTrueFalse);
+}
+
+public override bool SliderMotor(BulletConstraint constrain, int forceVel, int linAng, float val)
+{
+    BulletConstraintUnman constrainu = constrain as BulletConstraintUnman;
+    return BSAPICPP.SliderMotor2(constrainu.ptr, forceVel, linAng, val);
+}
+
 public override bool CalculateTransforms(BulletConstraint constrain)
 {
     BulletConstraintUnman constrainu = constrain as BulletConstraintUnman;
@@ -642,6 +725,13 @@ public override bool RemoveObjectFromWorld(BulletWorld world, BulletBody obj)
     return BSAPICPP.RemoveObjectFromWorld2(worldu.ptr, bodyu.ptr);
 }
 
+public override bool ClearCollisionProxyCache(BulletWorld world, BulletBody obj)
+{
+    BulletWorldUnman worldu = world as BulletWorldUnman;
+    BulletBodyUnman bodyu = obj as BulletBodyUnman;
+    return BSAPICPP.ClearCollisionProxyCache2(worldu.ptr, bodyu.ptr);
+}
+
 public override bool AddConstraintToWorld(BulletWorld world, BulletConstraint constrain, bool disableCollisionsBetweenLinkedObjects)
 {
     BulletWorldUnman worldu = world as BulletWorldUnman;
@@ -1407,11 +1497,24 @@ public static extern IntPtr CreateMeshShape2(IntPtr world,
                 int verticesCount, [MarshalAs(UnmanagedType.LPArray)] float[] vertices );
 
 [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern IntPtr CreateGImpactShape2(IntPtr world,
+                int indicesCount, [MarshalAs(UnmanagedType.LPArray)] int[] indices,
+                int verticesCount, [MarshalAs(UnmanagedType.LPArray)] float[] vertices );
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
 public static extern IntPtr CreateHullShape2(IntPtr world,
                 int hullCount, [MarshalAs(UnmanagedType.LPArray)] float[] hulls);
 
 [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
-public static extern IntPtr BuildHullShapeFromMesh2(IntPtr world, IntPtr meshShape);
+public static extern IntPtr BuildHullShapeFromMesh2(IntPtr world, IntPtr meshShape, HACDParams parms);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern IntPtr BuildConvexHullShapeFromMesh2(IntPtr world, IntPtr meshShape);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern IntPtr CreateConvexHullShape2(IntPtr world,
+                int indicesCount, [MarshalAs(UnmanagedType.LPArray)] int[] indices,
+                int verticesCount, [MarshalAs(UnmanagedType.LPArray)] float[] vertices );
 
 [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
 public static extern IntPtr BuildNativeShape2(IntPtr world, ShapeData shapeData);
@@ -1476,7 +1579,7 @@ public static extern void DestroyObject2(IntPtr sim, IntPtr obj);
 public static extern IntPtr CreateGroundPlaneShape2(uint id, float height, float collisionMargin);
 
 [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
-public static extern IntPtr CreateTerrainShape2(uint id, Vector3 size, float minHeight, float maxHeight, 
+public static extern IntPtr CreateTerrainShape2(uint id, Vector3 size, float minHeight, float maxHeight,
                                             [MarshalAs(UnmanagedType.LPArray)] float[] heightMap,
                                             float scaleFactor, float collisionMargin);
 
@@ -1559,6 +1662,33 @@ public static extern bool TranslationalLimitMotor2(IntPtr constrain, float enabl
 public static extern bool SetBreakingImpulseThreshold2(IntPtr constrain, float threshold);
 
 [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern bool HingeSetLimits2(IntPtr constrain, float low, float high, float softness, float bias, float relaxation);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern bool ConstraintSpringEnable2(IntPtr constrain, int index, float numericTrueFalse);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern bool ConstraintSpringSetEquilibriumPoint2(IntPtr constrain, int index, float equilibriumPoint);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern bool ConstraintSpringSetStiffness2(IntPtr constrain, int index, float stiffness);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern bool ConstraintSpringSetDamping2(IntPtr constrain, int index, float damping);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern bool SliderSetLimits2(IntPtr constrain, int lowerUpper, int linAng, float val);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern bool SliderSet2(IntPtr constrain, int softRestDamp, int dirLimOrtho, int linAng, float val);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern bool SliderMotorEnable2(IntPtr constrain, int linAng, float numericTrueFalse);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern bool SliderMotor2(IntPtr constrain, int forceVel, int linAng, float val);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
 public static extern bool CalculateTransforms2(IntPtr constrain);
 
 [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
@@ -1590,6 +1720,9 @@ public static extern bool AddObjectToWorld2(IntPtr world, IntPtr obj);
 public static extern bool RemoveObjectFromWorld2(IntPtr world, IntPtr obj);
 
 [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern bool ClearCollisionProxyCache2(IntPtr world, IntPtr obj);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
 public static extern bool AddConstraintToWorld2(IntPtr world, IntPtr constrain, bool disableCollisionsBetweenLinkedObjects);
 
 [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
diff --git a/OpenSim/Region/Physics/BulletSPlugin/BSAPIXNA.cs b/OpenSim/Region/Physics/BulletSPlugin/BSAPIXNA.cs
index 6fc10e9..17ebed2 100755
--- a/OpenSim/Region/Physics/BulletSPlugin/BSAPIXNA.cs
+++ b/OpenSim/Region/Physics/BulletSPlugin/BSAPIXNA.cs
@@ -81,11 +81,11 @@ private sealed class BulletBodyXNA : BulletBody
 private sealed class BulletShapeXNA : BulletShape
 {
     public CollisionShape shape;
-    public BulletShapeXNA(CollisionShape xx, BSPhysicsShapeType typ) 
+    public BulletShapeXNA(CollisionShape xx, BSPhysicsShapeType typ)
         : base()
     {
         shape = xx;
-        type = typ;
+        shapeType = typ;
     }
     public override bool HasPhysicalShape
     {
@@ -97,7 +97,7 @@ private sealed class BulletShapeXNA : BulletShape
     }
     public override BulletShape Clone()
     {
-        return new BulletShapeXNA(shape, type);
+        return new BulletShapeXNA(shape, shapeType);
     }
     public override bool ReferenceSame(BulletShape other)
     {
@@ -137,8 +137,8 @@ private sealed class BulletConstraintXNA : BulletConstraint
     internal int LastEntityProperty = 0;
 
     internal EntityProperties[] UpdatedObjects;
-    internal Dictionary<uint, GhostObject> specialCollisionObjects; 
-    
+    internal Dictionary<uint, GhostObject> specialCollisionObjects;
+
     private static int m_collisionsThisFrame;
     private BSScene PhysicsScene { get; set; }
 
@@ -151,7 +151,7 @@ private sealed class BulletConstraintXNA : BulletConstraint
     }
 
     /// <summary>
-    /// 
+    ///
     /// </summary>
     /// <param name="p"></param>
     /// <param name="p_2"></param>
@@ -169,12 +169,25 @@ private sealed class BulletConstraintXNA : BulletConstraint
         return true;
     }
 
+    public override bool ClearCollisionProxyCache(BulletWorld pWorld, BulletBody pBody)
+    {
+        DiscreteDynamicsWorld world = (pWorld as BulletWorldXNA).world;
+        RigidBody body = ((BulletBodyXNA)pBody).rigidBody;
+        CollisionObject collisionObject = ((BulletBodyXNA)pBody).body;
+        if (body != null && collisionObject != null && collisionObject.GetBroadphaseHandle() != null)
+        {
+            world.RemoveCollisionObject(collisionObject);
+            world.AddCollisionObject(collisionObject);
+        }
+        return true;
+    }
+
     public override bool AddConstraintToWorld(BulletWorld pWorld, BulletConstraint pConstraint, bool pDisableCollisionsBetweenLinkedObjects)
     {
         DiscreteDynamicsWorld world = (pWorld as BulletWorldXNA).world;
         TypedConstraint constraint = (pConstraint as BulletConstraintXNA).constrain;
         world.AddConstraint(constraint, pDisableCollisionsBetweenLinkedObjects);
-        
+
         return true;
 
     }
@@ -300,7 +313,7 @@ private sealed class BulletConstraintXNA : BulletConstraint
     public override bool GetForceUpdateAllAabbs(BulletWorld pWorld) {
         DiscreteDynamicsWorld world = (pWorld as BulletWorldXNA).world;
         return world.GetForceUpdateAllAabbs();
-        
+
     }
     public override void SetForceUpdateAllAabbs(BulletWorld pWorld, bool pForce)
     {
@@ -404,7 +417,7 @@ private sealed class BulletConstraintXNA : BulletConstraint
         IndexedMatrix mat = IndexedMatrix.CreateFromQuaternion(vquaternion);
         mat._origin = vposition;
         collisionObject.SetWorldTransform(mat);
-        
+
     }
 
     public override Vector3 GetPosition(BulletBody pCollisionObject)
@@ -457,7 +470,7 @@ private sealed class BulletConstraintXNA : BulletConstraint
     {
         CollisionObject collisionObject = (pCollisionObject as BulletBodyXNA).rigidBody;
         collisionObject.Activate(pforceactivation);
-        
+
     }
 
     public override Quaternion GetOrientation(BulletBody pCollisionObject)
@@ -486,7 +499,7 @@ private sealed class BulletConstraintXNA : BulletConstraint
     {
         CollisionObject collisionObject = (pCollisionObject as BulletBodyXNA).rigidBody;
         return collisionObject.GetCcdSweptSphereRadius();
-        
+
     }
 
     public override IntPtr GetUserPointer(BulletBody pCollisionObject)
@@ -559,8 +572,8 @@ private sealed class BulletConstraintXNA : BulletConstraint
     }
 
 
-    public override BulletConstraint Create6DofConstraint(BulletWorld pWorld, BulletBody pBody1, BulletBody pBody2, 
-                                    Vector3 pframe1, Quaternion pframe1rot, Vector3 pframe2, Quaternion pframe2rot, 
+    public override BulletConstraint Create6DofConstraint(BulletWorld pWorld, BulletBody pBody1, BulletBody pBody2,
+                                    Vector3 pframe1, Quaternion pframe1rot, Vector3 pframe2, Quaternion pframe2rot,
                                     bool puseLinearReferenceFrameA, bool pdisableCollisionsBetweenLinkedBodies)
 
     {
@@ -604,7 +617,7 @@ private sealed class BulletConstraintXNA : BulletConstraint
     }
 
     /// <summary>
-    /// 
+    ///
     /// </summary>
     /// <param name="pWorld"></param>
     /// <param name="pBody1"></param>
@@ -752,6 +765,214 @@ private sealed class BulletConstraintXNA : BulletConstraint
         constraint.SetBreakingImpulseThreshold(threshold);
         return true;
     }
+    public override bool HingeSetLimits(BulletConstraint pConstraint, float low, float high, float softness, float bias, float relaxation)
+    {
+        HingeConstraint constraint = (pConstraint as BulletConstraintXNA).constrain as HingeConstraint;
+        if (softness == HINGE_NOT_SPECIFIED)
+            constraint.SetLimit(low, high);
+        else
+            constraint.SetLimit(low, high, softness, bias, relaxation);
+        return true;
+    }
+    public override bool SpringEnable(BulletConstraint pConstraint, int index, float numericTrueFalse)
+    {
+        Generic6DofSpringConstraint constraint = (pConstraint as BulletConstraintXNA).constrain as Generic6DofSpringConstraint;
+        constraint.EnableSpring(index, (numericTrueFalse == 0f ? false : true));
+        return true;
+    }
+
+    public override bool SpringSetEquilibriumPoint(BulletConstraint pConstraint, int index, float equilibriumPoint)
+    {
+        Generic6DofSpringConstraint constraint = (pConstraint as BulletConstraintXNA).constrain as Generic6DofSpringConstraint;
+        if (index == SPRING_NOT_SPECIFIED)
+        {
+            constraint.SetEquilibriumPoint();
+        }
+        else
+        {
+            if (equilibriumPoint == SPRING_NOT_SPECIFIED)
+                constraint.SetEquilibriumPoint(index);
+            else
+                constraint.SetEquilibriumPoint(index, equilibriumPoint);
+        }
+        return true;
+    }
+
+    public override bool SpringSetStiffness(BulletConstraint pConstraint, int index, float stiffness)
+    {
+        Generic6DofSpringConstraint constraint = (pConstraint as BulletConstraintXNA).constrain as Generic6DofSpringConstraint;
+        constraint.SetStiffness(index, stiffness);
+        return true;
+    }
+
+    public override bool SpringSetDamping(BulletConstraint pConstraint, int index, float damping)
+    {
+        Generic6DofSpringConstraint constraint = (pConstraint as BulletConstraintXNA).constrain as Generic6DofSpringConstraint;
+        constraint.SetDamping(index, damping);
+        return true;
+    }
+
+    public override bool SliderSetLimits(BulletConstraint pConstraint, int lowerUpper, int linAng, float val)
+    {
+        SliderConstraint constraint = (pConstraint as BulletConstraintXNA).constrain as SliderConstraint;
+                switch (lowerUpper)
+                {
+                        case SLIDER_LOWER_LIMIT:
+                                switch (linAng)
+                                {
+                                        case SLIDER_LINEAR:
+                                                constraint.SetLowerLinLimit(val);
+                                                break;
+                                        case SLIDER_ANGULAR:
+                                                constraint.SetLowerAngLimit(val);
+                                                break;
+                                }
+                                break;
+                        case SLIDER_UPPER_LIMIT:
+                                switch (linAng)
+                                {
+                                        case SLIDER_LINEAR:
+                                                constraint.SetUpperLinLimit(val);
+                                                break;
+                                        case SLIDER_ANGULAR:
+                                                constraint.SetUpperAngLimit(val);
+                                                break;
+                                }
+                                break;
+                }
+        return true;
+    }
+    public override bool SliderSet(BulletConstraint pConstraint, int softRestDamp, int dirLimOrtho, int linAng, float val)
+    {
+        SliderConstraint constraint = (pConstraint as BulletConstraintXNA).constrain as SliderConstraint;
+                switch (softRestDamp)
+                {
+                        case SLIDER_SET_SOFTNESS:
+                                switch (dirLimOrtho)
+                                {
+                                        case SLIDER_SET_DIRECTION:
+                                                switch (linAng)
+                                                {
+                                                        case SLIDER_LINEAR: constraint.SetSoftnessDirLin(val); break;
+                                                        case SLIDER_ANGULAR: constraint.SetSoftnessDirAng(val); break;
+                                                }
+                                                break;
+                                        case SLIDER_SET_LIMIT:
+                                                switch (linAng)
+                                                {
+                                                        case SLIDER_LINEAR: constraint.SetSoftnessLimLin(val); break;
+                                                        case SLIDER_ANGULAR: constraint.SetSoftnessLimAng(val); break;
+                                                }
+                                                break;
+                                        case SLIDER_SET_ORTHO:
+                                                switch (linAng)
+                                                {
+                                                        case SLIDER_LINEAR: constraint.SetSoftnessOrthoLin(val); break;
+                                                        case SLIDER_ANGULAR: constraint.SetSoftnessOrthoAng(val); break;
+                                                }
+                                                break;
+                                }
+                                break;
+                        case SLIDER_SET_RESTITUTION:
+                                switch (dirLimOrtho)
+                                {
+                                        case SLIDER_SET_DIRECTION:
+                                                switch (linAng)
+                                                {
+                                                        case SLIDER_LINEAR: constraint.SetRestitutionDirLin(val); break;
+                                                        case SLIDER_ANGULAR: constraint.SetRestitutionDirAng(val); break;
+                                                }
+                                                break;
+                                        case SLIDER_SET_LIMIT:
+                                                switch (linAng)
+                                                {
+                                                        case SLIDER_LINEAR: constraint.SetRestitutionLimLin(val); break;
+                                                        case SLIDER_ANGULAR: constraint.SetRestitutionLimAng(val); break;
+                                                }
+                                                break;
+                                        case SLIDER_SET_ORTHO:
+                                                switch (linAng)
+                                                {
+                                                        case SLIDER_LINEAR: constraint.SetRestitutionOrthoLin(val); break;
+                                                        case SLIDER_ANGULAR: constraint.SetRestitutionOrthoAng(val); break;
+                                                }
+                                                break;
+                                }
+                                break;
+                        case SLIDER_SET_DAMPING:
+                                switch (dirLimOrtho)
+                                {
+                                        case SLIDER_SET_DIRECTION:
+                                                switch (linAng)
+                                                {
+                                                        case SLIDER_LINEAR: constraint.SetDampingDirLin(val); break;
+                                                        case SLIDER_ANGULAR: constraint.SetDampingDirAng(val); break;
+                                                }
+                                                break;
+                                        case SLIDER_SET_LIMIT:
+                                                switch (linAng)
+                                                {
+                                                        case SLIDER_LINEAR: constraint.SetDampingLimLin(val); break;
+                                                        case SLIDER_ANGULAR: constraint.SetDampingLimAng(val); break;
+                                                }
+                                                break;
+                                        case SLIDER_SET_ORTHO:
+                                                switch (linAng)
+                                                {
+                                                        case SLIDER_LINEAR: constraint.SetDampingOrthoLin(val); break;
+                                                        case SLIDER_ANGULAR: constraint.SetDampingOrthoAng(val); break;
+                                                }
+                                                break;
+                                }
+                                break;
+                }
+        return true;
+    }
+    public override bool SliderMotorEnable(BulletConstraint pConstraint, int linAng, float numericTrueFalse)
+    {
+        SliderConstraint constraint = (pConstraint as BulletConstraintXNA).constrain as SliderConstraint;
+                switch (linAng)
+                {
+                        case SLIDER_LINEAR:
+                                constraint.SetPoweredLinMotor(numericTrueFalse == 0.0 ? false : true);
+                                break;
+                        case SLIDER_ANGULAR:
+                                constraint.SetPoweredAngMotor(numericTrueFalse == 0.0 ? false : true);
+                                break;
+                }
+        return true;
+    }
+    public override bool SliderMotor(BulletConstraint pConstraint, int forceVel, int linAng, float val)
+    {
+        SliderConstraint constraint = (pConstraint as BulletConstraintXNA).constrain as SliderConstraint;
+                switch (forceVel)
+                {
+                        case SLIDER_MOTOR_VELOCITY:
+                                switch (linAng)
+                                {
+                                        case SLIDER_LINEAR:
+                                                constraint.SetTargetLinMotorVelocity(val);
+                                                break;
+                                        case SLIDER_ANGULAR:
+                                                constraint.SetTargetAngMotorVelocity(val);
+                                                break;
+                                }
+                                break;
+                        case SLIDER_MAX_MOTOR_FORCE:
+                                switch (linAng)
+                                {
+                                        case SLIDER_LINEAR:
+                                                constraint.SetMaxLinMotorForce(val);
+                                                break;
+                                        case SLIDER_ANGULAR:
+                                                constraint.SetMaxAngMotorForce(val);
+                                                break;
+                                }
+                                break;
+                }
+        return true;
+    }
+
     //BulletSimAPI.SetAngularDamping(Prim.PhysBody.ptr, angularDamping);
     public override void SetAngularDamping(BulletBody pBody, float angularDamping)
     {
@@ -824,7 +1045,7 @@ private sealed class BulletConstraintXNA : BulletConstraint
     {
         RigidBody body = (pBody as BulletBodyXNA).rigidBody;
         float angularDamping = body.GetAngularDamping();
-        body.SetDamping(lin_damping, angularDamping); 
+        body.SetDamping(lin_damping, angularDamping);
     }
 
     public override float GetLinearDamping(BulletBody pBody)
@@ -907,7 +1128,7 @@ private sealed class BulletConstraintXNA : BulletConstraint
         RigidBody bo = co as RigidBody;
         if (bo == null)
         {
-            
+
             if (world.IsInWorld(co))
             {
                 world.RemoveCollisionObject(co);
@@ -915,7 +1136,7 @@ private sealed class BulletConstraintXNA : BulletConstraint
         }
         else
         {
-            
+
             if (world.IsInWorld(bo))
             {
                 world.RemoveRigidBody(bo);
@@ -947,7 +1168,7 @@ private sealed class BulletConstraintXNA : BulletConstraint
 
         // TODO:  Turn this from a reference copy to a Value Copy.
         BulletShapeXNA shape2 = new BulletShapeXNA(shape1, BSShapeTypeFromBroadPhaseNativeType(shape1.GetShapeType()));
-        
+
         return shape2;
     }
 
@@ -957,7 +1178,7 @@ private sealed class BulletConstraintXNA : BulletConstraint
         return false;
     }
     //(sim.ptr, shape.ptr, prim.LocalID, prim.RawPosition, prim.RawOrientation);
-               
+
     public override BulletBody CreateBodyFromShape(BulletWorld pWorld, BulletShape pShape, uint pLocalID, Vector3 pRawPosition, Quaternion pRawOrientation)
     {
         CollisionWorld world = (pWorld as BulletWorldXNA).world;
@@ -993,11 +1214,11 @@ private sealed class BulletConstraintXNA : BulletConstraint
             m_startWorldTransform = IndexedMatrix.Identity;
         */
         body.SetUserPointer(pLocalID);
-        
+
         return new BulletBodyXNA(pLocalID, body);
     }
 
-    
+
     public override BulletBody CreateBodyWithDefaultMotionState( BulletShape pShape, uint pLocalID, Vector3 pRawPosition, Quaternion pRawOrientation)
     {
 
@@ -1025,7 +1246,7 @@ private sealed class BulletConstraintXNA : BulletConstraint
     public override Vector3 GetAnisotripicFriction(BulletConstraint pconstrain)
     {
 
-        /* TODO */ 
+        /* TODO */
         return Vector3.Zero;
     }
     public override Vector3 SetAnisotripicFriction(BulletConstraint pconstrain, Vector3 frict) { /* TODO */ return Vector3.Zero; }
@@ -1035,7 +1256,7 @@ private sealed class BulletConstraintXNA : BulletConstraint
     {
         CollisionObject collisionObject = (pCollisionObject as BulletBodyXNA).rigidBody;
         return collisionObject.IsStaticObject();
-        
+
     }
     public override bool IsKinematicObject(BulletBody pCollisionObject)
     {
@@ -1098,10 +1319,10 @@ private sealed class BulletConstraintXNA : BulletConstraint
         return new BulletWorldXNA(1, PhysicsScene, BSAPIXNA.Initialize2(worldExtent, configparms, maxCollisions, ref collisionArray, maxUpdates, ref updateArray, null));
     }
 
-    private static DiscreteDynamicsWorld Initialize2(Vector3 worldExtent, 
+    private static DiscreteDynamicsWorld Initialize2(Vector3 worldExtent,
                         ConfigurationParameters[] o,
                         int mMaxCollisionsPerFrame, ref CollisionDesc[] collisionArray,
-                        int mMaxUpdatesPerFrame, ref EntityProperties[] updateArray, 
+                        int mMaxUpdatesPerFrame, ref EntityProperties[] updateArray,
                         object mDebugLogCallbackHandle)
     {
         CollisionWorld.WorldData.ParamData p = new CollisionWorld.WorldData.ParamData();
@@ -1138,9 +1359,9 @@ private sealed class BulletConstraintXNA : BulletConstraint
         p.avatarCapsuleDepth = BSParam.AvatarCapsuleDepth;
         p.avatarCapsuleHeight = BSParam.AvatarCapsuleHeight;
         p.avatarContactProcessingThreshold = BSParam.AvatarContactProcessingThreshold;
-       
+
         p.vehicleAngularDamping = BSParam.VehicleAngularDamping;
-        
+
         p.maxPersistantManifoldPoolSize = o[0].maxPersistantManifoldPoolSize;
         p.maxCollisionAlgorithmPoolSize = o[0].maxCollisionAlgorithmPoolSize;
         p.shouldDisableContactPoolDynamicAllocation = o[0].shouldDisableContactPoolDynamicAllocation;
@@ -1160,7 +1381,7 @@ private sealed class BulletConstraintXNA : BulletConstraint
         p.linkConstraintSolverIterations = BSParam.LinkConstraintSolverIterations;
         p.physicsLoggingFrames = o[0].physicsLoggingFrames;
         DefaultCollisionConstructionInfo ccci = new DefaultCollisionConstructionInfo();
-        
+
         DefaultCollisionConfiguration cci = new DefaultCollisionConfiguration();
         CollisionDispatcher m_dispatcher = new CollisionDispatcher(cci);
 
@@ -1221,6 +1442,50 @@ private sealed class BulletConstraintXNA : BulletConstraint
         //BSParam.TerrainImplementation = 0;
         world.SetGravity(new IndexedVector3(0,0,p.gravity));
 
+        // Turn off Pooling since globals and pooling are bad for threading.
+        BulletGlobals.VoronoiSimplexSolverPool.SetPoolingEnabled(false);
+        BulletGlobals.SubSimplexConvexCastPool.SetPoolingEnabled(false);
+        BulletGlobals.ManifoldPointPool.SetPoolingEnabled(false);
+        BulletGlobals.CastResultPool.SetPoolingEnabled(false);
+        BulletGlobals.SphereShapePool.SetPoolingEnabled(false);
+        BulletGlobals.DbvtNodePool.SetPoolingEnabled(false);
+        BulletGlobals.SingleRayCallbackPool.SetPoolingEnabled(false);
+        BulletGlobals.SubSimplexClosestResultPool.SetPoolingEnabled(false);
+        BulletGlobals.GjkPairDetectorPool.SetPoolingEnabled(false);
+        BulletGlobals.DbvtTreeColliderPool.SetPoolingEnabled(false);
+        BulletGlobals.SingleSweepCallbackPool.SetPoolingEnabled(false);
+        BulletGlobals.BroadphaseRayTesterPool.SetPoolingEnabled(false);
+        BulletGlobals.ClosestNotMeConvexResultCallbackPool.SetPoolingEnabled(false);
+        BulletGlobals.GjkEpaPenetrationDepthSolverPool.SetPoolingEnabled(false);
+        BulletGlobals.ContinuousConvexCollisionPool.SetPoolingEnabled(false);
+        BulletGlobals.DbvtStackDataBlockPool.SetPoolingEnabled(false);
+
+        BulletGlobals.BoxBoxCollisionAlgorithmPool.SetPoolingEnabled(false);
+        BulletGlobals.CompoundCollisionAlgorithmPool.SetPoolingEnabled(false);
+        BulletGlobals.ConvexConcaveCollisionAlgorithmPool.SetPoolingEnabled(false);
+        BulletGlobals.ConvexConvexAlgorithmPool.SetPoolingEnabled(false);
+        BulletGlobals.ConvexPlaneAlgorithmPool.SetPoolingEnabled(false);
+        BulletGlobals.SphereBoxCollisionAlgorithmPool.SetPoolingEnabled(false);
+        BulletGlobals.SphereSphereCollisionAlgorithmPool.SetPoolingEnabled(false);
+        BulletGlobals.SphereTriangleCollisionAlgorithmPool.SetPoolingEnabled(false);
+        BulletGlobals.GImpactCollisionAlgorithmPool.SetPoolingEnabled(false);
+        BulletGlobals.GjkEpaSolver2MinkowskiDiffPool.SetPoolingEnabled(false);
+        BulletGlobals.PersistentManifoldPool.SetPoolingEnabled(false);
+        BulletGlobals.ManifoldResultPool.SetPoolingEnabled(false);
+        BulletGlobals.GJKPool.SetPoolingEnabled(false);
+        BulletGlobals.GIM_ShapeRetrieverPool.SetPoolingEnabled(false);
+        BulletGlobals.TriangleShapePool.SetPoolingEnabled(false);
+        BulletGlobals.SphereTriangleDetectorPool.SetPoolingEnabled(false);
+        BulletGlobals.CompoundLeafCallbackPool.SetPoolingEnabled(false);
+        BulletGlobals.GjkConvexCastPool.SetPoolingEnabled(false);
+        BulletGlobals.LocalTriangleSphereCastCallbackPool.SetPoolingEnabled(false);
+        BulletGlobals.BridgeTriangleRaycastCallbackPool.SetPoolingEnabled(false);
+        BulletGlobals.BridgeTriangleConcaveRaycastCallbackPool.SetPoolingEnabled(false);
+        BulletGlobals.BridgeTriangleConvexcastCallbackPool.SetPoolingEnabled(false);
+        BulletGlobals.MyNodeOverlapCallbackPool.SetPoolingEnabled(false);
+        BulletGlobals.ClosestRayResultCallbackPool.SetPoolingEnabled(false);
+        BulletGlobals.DebugDrawcallbackPool.SetPoolingEnabled(false);
+
         return world;
     }
     //m_constraint.ptr, ConstraintParams.BT_CONSTRAINT_STOP_CFM, cfm, ConstraintParamAxis.AXIS_ALL
@@ -1263,7 +1528,7 @@ private sealed class BulletConstraintXNA : BulletConstraint
             }
         }
         return ret;
-        
+
     }
 
     public override float GetAngularMotionDisc(BulletShape pShape)
@@ -1353,10 +1618,10 @@ private sealed class BulletConstraintXNA : BulletConstraint
         CollisionShape shape = (pShape as BulletShapeXNA).shape;
         gObj.SetCollisionShape(shape);
         gObj.SetUserPointer(pLocalID);
-        
+
         if (specialCollisionObjects.ContainsKey(pLocalID))
             specialCollisionObjects[pLocalID] = gObj;
-        else 
+        else
             specialCollisionObjects.Add(pLocalID, gObj);
 
         // TODO: Add to Special CollisionObjects!
@@ -1447,8 +1712,8 @@ private sealed class BulletConstraintXNA : BulletConstraint
         return new BulletShapeXNA(ret, BSShapeTypeFromBroadPhaseNativeType(ret.GetShapeType()));
     }
 
-    public override BulletShape GetChildShapeFromCompoundShapeIndex(BulletShape cShape, int indx) { 
-        
+    public override BulletShape GetChildShapeFromCompoundShapeIndex(BulletShape cShape, int indx) {
+
         if (cShape == null)
             return null;
         CompoundShape compoundShape = (cShape as BulletShapeXNA).shape as CompoundShape;
@@ -1456,7 +1721,7 @@ private sealed class BulletConstraintXNA : BulletConstraint
         BulletShape retShape = new BulletShapeXNA(shape, BSShapeTypeFromBroadPhaseNativeType(shape.GetShapeType()));
 
 
-        return retShape; 
+        return retShape;
     }
 
     public BSPhysicsShapeType BSShapeTypeFromBroadPhaseNativeType(BroadphaseNativeTypes pin)
@@ -1475,7 +1740,7 @@ private sealed class BulletConstraintXNA : BulletConstraint
                 ret =  BSPhysicsShapeType.SHAPE_UNKNOWN;
                 break;
             case BroadphaseNativeTypes.CONVEX_TRIANGLEMESH_SHAPE_PROXYTYPE:
-                ret =  BSPhysicsShapeType.SHAPE_MESH;
+                ret =  BSPhysicsShapeType.SHAPE_CONVEXHULL;
                 break;
             case BroadphaseNativeTypes.CONVEX_HULL_SHAPE_PROXYTYPE:
                 ret =  BSPhysicsShapeType.SHAPE_HULL;
@@ -1503,7 +1768,7 @@ private sealed class BulletConstraintXNA : BulletConstraint
                 ret =  BSPhysicsShapeType.SHAPE_CONE;
                 break;
             case BroadphaseNativeTypes.CONVEX_SHAPE_PROXYTYPE:
-                ret =  BSPhysicsShapeType.SHAPE_UNKNOWN;
+                ret =  BSPhysicsShapeType.SHAPE_CONVEXHULL;
                 break;
             case BroadphaseNativeTypes.CYLINDER_SHAPE_PROXYTYPE:
                 ret =  BSPhysicsShapeType.SHAPE_CYLINDER;
@@ -1547,7 +1812,7 @@ private sealed class BulletConstraintXNA : BulletConstraint
                 break;
             ///Used for GIMPACT Trimesh integration
             case BroadphaseNativeTypes.GIMPACT_SHAPE_PROXYTYPE:
-                ret =  BSPhysicsShapeType.SHAPE_MESH;
+                ret =  BSPhysicsShapeType.SHAPE_GIMPACT;
                 break;
             ///Multimaterial mesh
             case BroadphaseNativeTypes.MULTIMATERIAL_TRIANGLE_MESH_PROXYTYPE:
@@ -1598,8 +1863,8 @@ private sealed class BulletConstraintXNA : BulletConstraint
         return new BulletShapeXNA(m_planeshape, BSPhysicsShapeType.SHAPE_GROUNDPLANE);
     }
 
-    public override BulletConstraint Create6DofSpringConstraint(BulletWorld pWorld, BulletBody pBody1, BulletBody pBody2, 
-                                    Vector3 pframe1, Quaternion pframe1rot, Vector3 pframe2, Quaternion pframe2rot, 
+    public override BulletConstraint Create6DofSpringConstraint(BulletWorld pWorld, BulletBody pBody1, BulletBody pBody2,
+                                    Vector3 pframe1, Quaternion pframe1rot, Vector3 pframe2, Quaternion pframe2rot,
                                     bool puseLinearReferenceFrameA, bool pdisableCollisionsBetweenLinkedBodies)
 
     {
@@ -1745,7 +2010,7 @@ private sealed class BulletConstraintXNA : BulletConstraint
     {
         DiscreteDynamicsWorld world = (pWorld as BulletWorldXNA).world;
         CompoundShape compoundshape = new CompoundShape(false);
-        
+
         compoundshape.SetMargin(world.WorldSettings.Params.collisionMargin);
         int ii = 1;
 
@@ -1761,7 +2026,7 @@ private sealed class BulletConstraintXNA : BulletConstraint
             int ender = ((ii + 4) + (vertexCount*3));
             for (int iii = ii + 4; iii < ender; iii+=3)
             {
-               
+
                 virts.Add(new IndexedVector3(pConvHulls[iii], pConvHulls[iii + 1], pConvHulls[iii +2]));
             }
             ConvexHullShape convexShape = new ConvexHullShape(virts, vertexCount);
@@ -1769,26 +2034,35 @@ private sealed class BulletConstraintXNA : BulletConstraint
             compoundshape.AddChildShape(ref childTrans, convexShape);
             ii += (vertexCount*3 + 4);
         }
-        
+
         return new BulletShapeXNA(compoundshape, BSPhysicsShapeType.SHAPE_HULL);
     }
 
-    public override BulletShape BuildHullShapeFromMesh(BulletWorld world, BulletShape meshShape)
+    public override BulletShape BuildHullShapeFromMesh(BulletWorld world, BulletShape meshShape, HACDParams parms)
     {
         /* TODO */ return null;
+    }
 
+    public override BulletShape BuildConvexHullShapeFromMesh(BulletWorld world, BulletShape meshShape)
+    {
+        /* TODO */ return null;
+    }
+
+    public override BulletShape CreateConvexHullShape(BulletWorld pWorld, int pIndicesCount, int[] indices, int pVerticesCount, float[] verticesAsFloats)
+    {
+        /* TODO */ return null;
     }
 
     public override BulletShape CreateMeshShape(BulletWorld pWorld, int pIndicesCount, int[] indices, int pVerticesCount, float[] verticesAsFloats)
     {
         //DumpRaw(indices,verticesAsFloats,pIndicesCount,pVerticesCount);
-        
+
         for (int iter = 0; iter < pVerticesCount; iter++)
         {
             if (verticesAsFloats[iter] > 0 && verticesAsFloats[iter] < 0.0001) verticesAsFloats[iter] = 0;
             if (verticesAsFloats[iter] < 0 && verticesAsFloats[iter] > -0.0001) verticesAsFloats[iter] = 0;
         }
-        
+
         ObjectArray<int> indicesarr = new ObjectArray<int>(indices);
         ObjectArray<float> vertices = new ObjectArray<float>(verticesAsFloats);
         DumpRaw(indicesarr,vertices,pIndicesCount,pVerticesCount);
@@ -1802,7 +2076,7 @@ private sealed class BulletConstraintXNA : BulletConstraint
         mesh.m_vertexStride = 3;
         mesh.m_vertexType = PHY_ScalarType.PHY_FLOAT;
         mesh.m_triangleIndexStride = 3;
-        
+
         TriangleIndexVertexArray tribuilder = new TriangleIndexVertexArray();
         tribuilder.AddIndexedMesh(mesh, PHY_ScalarType.PHY_INTEGER);
         BvhTriangleMeshShape meshShape = new BvhTriangleMeshShape(tribuilder, true,true);
@@ -1811,9 +2085,14 @@ private sealed class BulletConstraintXNA : BulletConstraint
         return new BulletShapeXNA(meshShape, BSPhysicsShapeType.SHAPE_MESH);
 
     }
+    public override BulletShape CreateGImpactShape(BulletWorld pWorld, int pIndicesCount, int[] indices, int pVerticesCount, float[] verticesAsFloats)
+    {
+        // TODO:
+        return null;
+    }
     public static void DumpRaw(ObjectArray<int>indices, ObjectArray<float> vertices, int pIndicesCount,int pVerticesCount )
     {
-        
+
         String fileName = "objTest3.raw";
         String completePath = System.IO.Path.Combine(Util.configDir(), fileName);
         StreamWriter sw = new StreamWriter(completePath);
@@ -1839,7 +2118,7 @@ private sealed class BulletConstraintXNA : BulletConstraint
             string s = vertices[indices[i * 3]].ToString("0.0000");
             s += " " + vertices[indices[i * 3 + 1]].ToString("0.0000");
             s += " " + vertices[indices[i * 3 + 2]].ToString("0.0000");
-        
+
             sw.Write(s + "\n");
         }
 
@@ -1861,7 +2140,7 @@ private sealed class BulletConstraintXNA : BulletConstraint
         mesh.m_vertexStride = 3;
         mesh.m_vertexType = PHY_ScalarType.PHY_FLOAT;
         mesh.m_triangleIndexStride = 3;
-        
+
         TriangleIndexVertexArray tribuilder = new TriangleIndexVertexArray();
         tribuilder.AddIndexedMesh(mesh, PHY_ScalarType.PHY_INTEGER);
 
@@ -1892,7 +2171,7 @@ private sealed class BulletConstraintXNA : BulletConstraint
             sw.Close();
     }
 
-    public override BulletShape CreateTerrainShape(uint id, Vector3 size, float minHeight, float maxHeight, float[] heightMap, 
+    public override BulletShape CreateTerrainShape(uint id, Vector3 size, float minHeight, float maxHeight, float[] heightMap,
                                                                 float scaleFactor, float collisionMargin)
     {
         const int upAxis = 2;
@@ -1900,7 +2179,7 @@ private sealed class BulletConstraintXNA : BulletConstraint
                                                                            heightMap,  scaleFactor,
                                                                            minHeight, maxHeight, upAxis,
                                                                             false);
-        terrainShape.SetMargin(collisionMargin + 0.5f);
+        terrainShape.SetMargin(collisionMargin);
         terrainShape.SetUseDiamondSubdivision(true);
         terrainShape.SetUserPointer(id);
         return new BulletShapeXNA(terrainShape, BSPhysicsShapeType.SHAPE_TERRAIN);
@@ -1934,14 +2213,14 @@ private sealed class BulletConstraintXNA : BulletConstraint
         /* TODO */
         updatedEntityCount = 0;
         collidersCount = 0;
-        
+
 
         int ret = PhysicsStep2(world,timeStep,maxSubSteps,fixedTimeStep,out updatedEntityCount,out world.physicsScene.m_updateArray, out collidersCount, out world.physicsScene.m_collisionArray);
 
         return ret;
     }
 
-    private int PhysicsStep2(BulletWorld pWorld, float timeStep, int m_maxSubSteps, float m_fixedTimeStep, 
+    private int PhysicsStep2(BulletWorld pWorld, float timeStep, int m_maxSubSteps, float m_fixedTimeStep,
                     out int updatedEntityCount, out EntityProperties[] updatedEntities,
                     out int collidersCount, out CollisionDesc[] colliders)
     {
@@ -1950,24 +2229,24 @@ private sealed class BulletConstraintXNA : BulletConstraint
         return epic;
     }
 
-    private int PhysicsStepint(BulletWorld pWorld,float timeStep, int m_maxSubSteps, float m_fixedTimeStep, out int updatedEntityCount, 
+    private int PhysicsStepint(BulletWorld pWorld,float timeStep, int m_maxSubSteps, float m_fixedTimeStep, out int updatedEntityCount,
         out  EntityProperties[] updatedEntities, out int collidersCount, out CollisionDesc[] colliders, int maxCollisions, int maxUpdates)
     {
         int numSimSteps = 0;
         Array.Clear(UpdatedObjects, 0, UpdatedObjects.Length);
         Array.Clear(UpdatedCollisions, 0, UpdatedCollisions.Length);
         LastEntityProperty=0;
-        
+
 
 
 
 
 
         LastCollisionDesc=0;
-       
+
         updatedEntityCount = 0;
         collidersCount = 0;
-        
+
 
         if (pWorld is BulletWorldXNA)
         {
@@ -2024,7 +2303,7 @@ private sealed class BulletConstraintXNA : BulletConstraint
 
             collidersCount = LastCollisionDesc;
             colliders = UpdatedCollisions;
-                
+
 
         }
         else
@@ -2032,15 +2311,15 @@ private sealed class BulletConstraintXNA : BulletConstraint
             //if (updatedEntities is null)
             //updatedEntities = new List<BulletXNA.EntityProperties>();
             //updatedEntityCount = 0;
-            
-            
+
+
             //collidersCount = 0;
-           
+
             updatedEntities = new EntityProperties[0];
 
-            
+
             colliders = new CollisionDesc[0];
-        
+
         }
         return numSimSteps;
     }
@@ -2048,7 +2327,7 @@ private sealed class BulletConstraintXNA : BulletConstraint
     {
         IOverlappingPairCache cache = obj.GetOverlappingPairCache();
         ObjectArray<BroadphasePair> pairs = cache.GetOverlappingPairArray();
-        
+
         DiscreteDynamicsWorld world = (PhysicsScene.World as BulletWorldXNA).world;
         PersistentManifoldArray manifoldArray = new PersistentManifoldArray();
         BroadphasePair collisionPair;
@@ -2060,7 +2339,7 @@ private sealed class BulletConstraintXNA : BulletConstraint
         ManifoldPoint pt;
 
         int numPairs = pairs.Count;
-        
+
         for (int i = 0; i < numPairs; i++)
         {
             manifoldArray.Clear();
@@ -2069,7 +2348,7 @@ private sealed class BulletConstraintXNA : BulletConstraint
             collisionPair = world.GetPairCache().FindPair(pairs[i].m_pProxy0, pairs[i].m_pProxy1);
             if (collisionPair == null)
                 continue;
-            
+
             collisionPair.m_algorithm.GetAllContactManifolds(manifoldArray);
             for (int j = 0; j < manifoldArray.Count; j++)
             {
@@ -2092,7 +2371,7 @@ private sealed class BulletConstraintXNA : BulletConstraint
     }
     private static void RecordCollision(BSAPIXNA world, CollisionObject objA, CollisionObject objB, IndexedVector3 contact, IndexedVector3 norm, float penetration)
     {
-       
+
         IndexedVector3 contactNormal = norm;
         if ((objA.GetCollisionFlags() & BulletXNA.BulletCollision.CollisionFlags.BS_WANTS_COLLISIONS) == 0 &&
             (objB.GetCollisionFlags() & BulletXNA.BulletCollision.CollisionFlags.BS_WANTS_COLLISIONS) == 0)
@@ -2162,11 +2441,11 @@ private sealed class BulletConstraintXNA : BulletConstraint
             if (NotMe is BulletBodyXNA && NotMe.HasPhysicalBody)
             {
                 CollisionObject AvoidBody = (NotMe as BulletBodyXNA).body;
-                
+
                 IndexedVector3 rOrigin = new IndexedVector3(_RayOrigin.X, _RayOrigin.Y, _RayOrigin.Z);
                 IndexedVector3 rEnd = new IndexedVector3(_RayOrigin.X, _RayOrigin.Y, _RayOrigin.Z - pRayHeight);
                 using (
-                    ClosestNotMeRayResultCallback rayCallback = 
+                    ClosestNotMeRayResultCallback rayCallback =
                                             new ClosestNotMeRayResultCallback(rOrigin, rEnd, AvoidBody)
                     )
                 {
@@ -2182,9 +2461,9 @@ private sealed class BulletConstraintXNA : BulletConstraint
         return false;
     }
 }
-  
 
-   
+
+
 
     public class SimMotionState : DefaultMotionState
     {
@@ -2277,12 +2556,12 @@ private sealed class BulletConstraintXNA : BulletConstraint
                 m_lastProperties = m_properties;
                 if (m_world.LastEntityProperty < m_world.UpdatedObjects.Length)
                     m_world.UpdatedObjects[m_world.LastEntityProperty++]=(m_properties);
-                
+
                 //(*m_updatesThisFrame)[m_properties.ID] = &m_properties;
             }
-                
-                
-                
+
+
+
 
         }
         public override void SetRigidBody(RigidBody body)
@@ -2305,7 +2584,7 @@ private sealed class BulletConstraintXNA : BulletConstraint
             (((v1.Z - nEpsilon) < v2.Z) && (v2.Z < (v1.Z + nEpsilon))) &&
             (((v1.W - nEpsilon) < v2.W) && (v2.W < (v1.W + nEpsilon)));
         }
-        
+
     }
 }
 
diff --git a/OpenSim/Region/Physics/BulletSPlugin/BSActorAvatarMove.cs b/OpenSim/Region/Physics/BulletSPlugin/BSActorAvatarMove.cs
new file mode 100755
index 0000000..1bcf879
--- /dev/null
+++ b/OpenSim/Region/Physics/BulletSPlugin/BSActorAvatarMove.cs
@@ -0,0 +1,411 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyrightD
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSimulator Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+using OpenSim.Region.Physics.Manager;
+
+using OMV = OpenMetaverse;
+
+namespace OpenSim.Region.Physics.BulletSPlugin
+{
+public class BSActorAvatarMove : BSActor
+{
+    BSVMotor m_velocityMotor;
+
+    // Set to true if we think we're going up stairs.
+    //    This state is remembered because collisions will turn on and off as we go up stairs.
+    int m_walkingUpStairs;
+    // The amount the step up is applying. Used to smooth stair walking.
+    float m_lastStepUp;
+
+    // Jumping happens over several frames. If use applies up force while colliding, start the
+    //    jump and allow the jump to continue for this number of frames.
+    int m_jumpFrames = 0;
+    float m_jumpVelocity = 0f;
+
+    public BSActorAvatarMove(BSScene physicsScene, BSPhysObject pObj, string actorName)
+        : base(physicsScene, pObj, actorName)
+    {
+        m_velocityMotor = null;
+        m_walkingUpStairs = 0;
+        m_physicsScene.DetailLog("{0},BSActorAvatarMove,constructor", m_controllingPrim.LocalID);
+    }
+
+    // BSActor.isActive
+    public override bool isActive
+    {
+        get { return Enabled && m_controllingPrim.IsPhysicallyActive; }
+    }
+
+    // Release any connections and resources used by the actor.
+    // BSActor.Dispose()
+    public override void Dispose()
+    {
+        base.SetEnabled(false);
+        // Now that turned off, remove any state we have in the scene.
+        Refresh();
+    }
+
+    // Called when physical parameters (properties set in Bullet) need to be re-applied.
+    // Called at taint-time.
+    // BSActor.Refresh()
+    public override void Refresh()
+    {
+        m_physicsScene.DetailLog("{0},BSActorAvatarMove,refresh", m_controllingPrim.LocalID);
+
+        // If the object is physically active, add the hoverer prestep action
+        if (isActive)
+        {
+            ActivateAvatarMove();
+        }
+        else
+        {
+            DeactivateAvatarMove();
+        }
+    }
+
+    // The object's physical representation is being rebuilt so pick up any physical dependencies (constraints, ...).
+    //     Register a prestep action to restore physical requirements before the next simulation step.
+    // Called at taint-time.
+    // BSActor.RemoveDependencies()
+    public override void RemoveDependencies()
+    {
+        // Nothing to do for the hoverer since it is all software at pre-step action time.
+    }
+
+    // Usually called when target velocity changes to set the current velocity and the target
+    //     into the movement motor.
+    public void SetVelocityAndTarget(OMV.Vector3 vel, OMV.Vector3 targ, bool inTaintTime)
+    {
+        m_physicsScene.TaintedObject(inTaintTime, m_controllingPrim.LocalID, "BSActorAvatarMove.setVelocityAndTarget", delegate()
+        {
+            if (m_velocityMotor != null)
+            {
+                m_velocityMotor.Reset();
+                m_velocityMotor.SetTarget(targ);
+                m_velocityMotor.SetCurrent(vel);
+                m_velocityMotor.Enabled = true;
+            }
+        });
+    }
+
+    // If a hover motor has not been created, create one and start the hovering.
+    private void ActivateAvatarMove()
+    {
+        if (m_velocityMotor == null)
+        {
+            // Infinite decay and timescale values so motor only changes current to target values.
+            m_velocityMotor = new BSVMotor("BSCharacter.Velocity",
+                                                0.2f,                       // time scale
+                                                BSMotor.Infinite,           // decay time scale
+                                                1f                          // efficiency
+            );
+            m_velocityMotor.ErrorZeroThreshold = BSParam.AvatarStopZeroThreshold;
+            // _velocityMotor.PhysicsScene = PhysicsScene; // DEBUG DEBUG so motor will output detail log messages.
+            SetVelocityAndTarget(m_controllingPrim.RawVelocity, m_controllingPrim.TargetVelocity, true /* inTaintTime */);
+
+            m_physicsScene.BeforeStep += Mover;
+            m_controllingPrim.OnPreUpdateProperty += Process_OnPreUpdateProperty;
+
+            m_walkingUpStairs = 0;
+        }
+    }
+
+    private void DeactivateAvatarMove()
+    {
+        if (m_velocityMotor != null)
+        {
+            m_controllingPrim.OnPreUpdateProperty -= Process_OnPreUpdateProperty;
+            m_physicsScene.BeforeStep -= Mover;
+            m_velocityMotor = null;
+        }
+    }
+
+    // Called just before the simulation step. Update the vertical position for hoverness.
+    private void Mover(float timeStep)
+    {
+        // Don't do movement while the object is selected.
+        if (!isActive)
+            return;
+
+        // TODO: Decide if the step parameters should be changed depending on the avatar's
+        //     state (flying, colliding, ...). There is code in ODE to do this.
+
+        // COMMENTARY: when the user is making the avatar walk, except for falling, the velocity
+        //   specified for the avatar is the one that should be used. For falling, if the avatar
+        //   is not flying and is not colliding then it is presumed to be falling and the Z
+        //   component is not fooled with (thus allowing gravity to do its thing).
+        // When the avatar is standing, though, the user has specified a velocity of zero and
+        //   the avatar should be standing. But if the avatar is pushed by something in the world
+        //   (raising elevator platform, moving vehicle, ...) the avatar should be allowed to
+        //   move. Thus, the velocity cannot be forced to zero. The problem is that small velocity
+        //   errors can creap in and the avatar will slowly float off in some direction.
+        // So, the problem is that, when an avatar is standing, we cannot tell creaping error
+        //   from real pushing.
+        // The code below uses whether the collider is static or moving to decide whether to zero motion.
+
+        m_velocityMotor.Step(timeStep);
+        m_controllingPrim.IsStationary = false;
+
+        // If we're not supposed to be moving, make sure things are zero.
+        if (m_velocityMotor.ErrorIsZero() && m_velocityMotor.TargetValue == OMV.Vector3.Zero)
+        {
+            // The avatar shouldn't be moving
+            m_velocityMotor.Zero();
+
+            if (m_controllingPrim.IsColliding)
+            {
+                // If we are colliding with a stationary object, presume we're standing and don't move around
+                if (!m_controllingPrim.ColliderIsMoving && !m_controllingPrim.ColliderIsVolumeDetect)
+                {
+                    m_physicsScene.DetailLog("{0},BSCharacter.MoveMotor,collidingWithStationary,zeroingMotion", m_controllingPrim.LocalID);
+                    m_controllingPrim.IsStationary = true;
+                    m_controllingPrim.ZeroMotion(true /* inTaintTime */);
+                }
+
+                // Standing has more friction on the ground
+                if (m_controllingPrim.Friction != BSParam.AvatarStandingFriction)
+                {
+                    m_controllingPrim.Friction = BSParam.AvatarStandingFriction;
+                    m_physicsScene.PE.SetFriction(m_controllingPrim.PhysBody, m_controllingPrim.Friction);
+                }
+            }
+            else
+            {
+                if (m_controllingPrim.Flying)
+                {
+                    // Flying and not colliding and velocity nearly zero.
+                    m_controllingPrim.ZeroMotion(true /* inTaintTime */);
+                }
+            }
+
+            m_physicsScene.DetailLog("{0},BSCharacter.MoveMotor,taint,stopping,target={1},colliding={2}",
+                            m_controllingPrim.LocalID, m_velocityMotor.TargetValue, m_controllingPrim.IsColliding);
+        }
+        else
+        {
+            // Supposed to be moving.
+            OMV.Vector3 stepVelocity = m_velocityMotor.CurrentValue;
+
+            if (m_controllingPrim.Friction != BSParam.AvatarFriction)
+            {
+                // Probably starting to walk. Set friction to moving friction.
+                m_controllingPrim.Friction = BSParam.AvatarFriction;
+                m_physicsScene.PE.SetFriction(m_controllingPrim.PhysBody, m_controllingPrim.Friction);
+            }
+
+            if (!m_controllingPrim.Flying && !m_controllingPrim.IsColliding)
+            {
+                stepVelocity.Z = m_controllingPrim.RawVelocity.Z;
+            }
+
+
+            // Colliding and not flying with an upward force. The avatar must be trying to jump.
+            if (!m_controllingPrim.Flying && m_controllingPrim.IsColliding && stepVelocity.Z > 0)
+            {
+                // We allow the upward force to happen for this many frames.
+                m_jumpFrames = BSParam.AvatarJumpFrames;
+                m_jumpVelocity = stepVelocity.Z;
+            }
+
+            // The case where the avatar is not colliding and is not flying is special.
+            // The avatar is either falling or jumping and the user can be applying force to the avatar
+            //     (force in some direction or force up or down).
+            // If the avatar has negative Z velocity and is not colliding, presume we're falling and keep the velocity.
+            // If the user is trying to apply upward force but we're not colliding, assume the avatar
+            //     is trying to jump and don't apply the upward force if not touching the ground any more.
+            if (!m_controllingPrim.Flying && !m_controllingPrim.IsColliding)
+            {
+                // If upward velocity is being applied, this must be a jump and only allow that to go on so long
+                if (m_jumpFrames > 0)
+                {
+                    // Since not touching the ground, only apply upward force for so long.
+                    m_jumpFrames--;
+                    stepVelocity.Z = m_jumpVelocity;
+                }
+                else
+                {
+                    // Since we're not affected by anything, whatever vertical motion the avatar has, continue that.
+                    stepVelocity.Z = m_controllingPrim.RawVelocity.Z;
+                }
+                // DetailLog("{0},BSCharacter.MoveMotor,taint,overrideStepZWithWorldZ,stepVel={1}", LocalID, stepVelocity);
+            }
+
+            // 'stepVelocity' is now the speed we'd like the avatar to move in. Turn that into an instantanous force.
+            OMV.Vector3 moveForce = (stepVelocity - m_controllingPrim.RawVelocity) * m_controllingPrim.Mass;
+
+            // Add special movement force to allow avatars to walk up stepped surfaces.
+            moveForce += WalkUpStairs();
+
+            m_physicsScene.DetailLog("{0},BSCharacter.MoveMotor,move,stepVel={1},vel={2},mass={3},moveForce={4}",
+                            m_controllingPrim.LocalID, stepVelocity, m_controllingPrim.RawVelocity, m_controllingPrim.Mass, moveForce);
+            m_physicsScene.PE.ApplyCentralImpulse(m_controllingPrim.PhysBody, moveForce);
+        }
+    }
+
+    // Called just as the property update is received from the physics engine.
+    // Do any mode necessary for avatar movement.
+    private void Process_OnPreUpdateProperty(ref EntityProperties entprop)
+    {
+        // Don't change position if standing on a stationary object.
+        if (m_controllingPrim.IsStationary)
+        {
+            entprop.Position = m_controllingPrim.RawPosition;
+            entprop.Velocity = OMV.Vector3.Zero;
+            m_physicsScene.PE.SetTranslation(m_controllingPrim.PhysBody, entprop.Position, entprop.Rotation);
+        }
+
+    }
+
+    // Decide if the character is colliding with a low object and compute a force to pop the
+    //    avatar up so it can walk up and over the low objects.
+    private OMV.Vector3 WalkUpStairs()
+    {
+        OMV.Vector3 ret = OMV.Vector3.Zero;
+
+        m_physicsScene.DetailLog("{0},BSCharacter.WalkUpStairs,IsColliding={1},flying={2},targSpeed={3},collisions={4},avHeight={5}",
+                        m_controllingPrim.LocalID, m_controllingPrim.IsColliding, m_controllingPrim.Flying,
+                        m_controllingPrim.TargetVelocitySpeed, m_controllingPrim.CollisionsLastTick.Count, m_controllingPrim.Size.Z);
+
+        // Check for stairs climbing if colliding, not flying and moving forward
+        if ( m_controllingPrim.IsColliding
+                    && !m_controllingPrim.Flying
+                    && m_controllingPrim.TargetVelocitySpeed > 0.1f )
+        {
+            // The range near the character's feet where we will consider stairs
+            // float nearFeetHeightMin = m_controllingPrim.RawPosition.Z - (m_controllingPrim.Size.Z / 2f) + 0.05f;
+            // Note: there is a problem with the computation of the capsule height. Thus RawPosition is off
+            //    from the height. Revisit size and this computation when height is scaled properly.
+            float nearFeetHeightMin = m_controllingPrim.RawPosition.Z - (m_controllingPrim.Size.Z / 2f) - 0.05f;
+            float nearFeetHeightMax = nearFeetHeightMin + BSParam.AvatarStepHeight;
+
+            // Look for a collision point that is near the character's feet and is oriented the same as the charactor is.
+            // Find the highest 'good' collision.
+            OMV.Vector3 highestTouchPosition = OMV.Vector3.Zero;
+            foreach (KeyValuePair<uint, ContactPoint> kvp in m_controllingPrim.CollisionsLastTick.m_objCollisionList)
+            {
+                // Don't care about collisions with the terrain
+                if (kvp.Key > m_physicsScene.TerrainManager.HighestTerrainID)
+                {
+                    BSPhysObject collisionObject;
+                    if (m_physicsScene.PhysObjects.TryGetValue(kvp.Key, out collisionObject))
+                    {
+                        if (!collisionObject.IsVolumeDetect)
+                        {
+                            OMV.Vector3 touchPosition = kvp.Value.Position;
+                            m_physicsScene.DetailLog("{0},BSCharacter.WalkUpStairs,min={1},max={2},touch={3}",
+                                            m_controllingPrim.LocalID, nearFeetHeightMin, nearFeetHeightMax, touchPosition);
+                            if (touchPosition.Z >= nearFeetHeightMin && touchPosition.Z <= nearFeetHeightMax)
+                            {
+                                // This contact is within the 'near the feet' range.
+                                // The normal should be our contact point to the object so it is pointing away
+                                //    thus the difference between our facing orientation and the normal should be small.
+                                OMV.Vector3 directionFacing = OMV.Vector3.UnitX * m_controllingPrim.RawOrientation;
+                                OMV.Vector3 touchNormal = OMV.Vector3.Normalize(kvp.Value.SurfaceNormal);
+                                float diff = Math.Abs(OMV.Vector3.Distance(directionFacing, touchNormal));
+                                if (diff < BSParam.AvatarStepApproachFactor)
+                                {
+                                    if (highestTouchPosition.Z < touchPosition.Z)
+                                        highestTouchPosition = touchPosition;
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            m_walkingUpStairs = 0;
+            // If there is a good step sensing, move the avatar over the step.
+            if (highestTouchPosition != OMV.Vector3.Zero)
+            {
+                // Remember that we are going up stairs. This is needed because collisions
+                //    will stop when we move up so this smoothes out that effect.
+                m_walkingUpStairs = BSParam.AvatarStepSmoothingSteps;
+
+                m_lastStepUp = highestTouchPosition.Z - nearFeetHeightMin;
+                ret = ComputeStairCorrection(m_lastStepUp);
+                m_physicsScene.DetailLog("{0},BSCharacter.WalkUpStairs,touchPos={1},nearFeetMin={2},ret={3}",
+                        m_controllingPrim.LocalID, highestTouchPosition, nearFeetHeightMin, ret);
+            }
+        }
+        else
+        {
+            // If we used to be going up stairs but are not now, smooth the case where collision goes away while
+            //    we are bouncing up the stairs.
+            if (m_walkingUpStairs > 0)
+            {
+                m_walkingUpStairs--;
+                ret = ComputeStairCorrection(m_lastStepUp);
+            }
+        }
+
+        return ret;
+    }
+
+    private OMV.Vector3 ComputeStairCorrection(float stepUp)
+    {
+        OMV.Vector3 ret = OMV.Vector3.Zero;
+        OMV.Vector3 displacement = OMV.Vector3.Zero;
+
+        if (stepUp > 0f)
+        {
+            // Found the stairs contact point. Push up a little to raise the character.
+            if (BSParam.AvatarStepForceFactor > 0f)
+            {
+                float upForce = stepUp * m_controllingPrim.Mass * BSParam.AvatarStepForceFactor;
+                ret = new OMV.Vector3(0f, 0f, upForce);
+            }
+
+            // Also move the avatar up for the new height
+            if (BSParam.AvatarStepUpCorrectionFactor > 0f)
+            {
+                // Move the avatar up related to the height of the collision
+                displacement = new OMV.Vector3(0f, 0f, stepUp * BSParam.AvatarStepUpCorrectionFactor);
+                m_controllingPrim.ForcePosition = m_controllingPrim.RawPosition + displacement;
+            }
+            else
+            {
+                if (BSParam.AvatarStepUpCorrectionFactor < 0f)
+                {
+                    // Move the avatar up about the specified step height
+                    displacement = new OMV.Vector3(0f, 0f, BSParam.AvatarStepHeight);
+                    m_controllingPrim.ForcePosition = m_controllingPrim.RawPosition + displacement;
+                }
+            }
+            m_physicsScene.DetailLog("{0},BSCharacter.WalkUpStairs.ComputeStairCorrection,disp={1},force={2}",
+                                        m_controllingPrim.LocalID, displacement, ret);
+
+        }
+        return ret;
+    }
+}
+}
+
+
diff --git a/OpenSim/Region/Physics/BulletSPlugin/BSActorHover.cs b/OpenSim/Region/Physics/BulletSPlugin/BSActorHover.cs
new file mode 100755
index 0000000..8a79809
--- /dev/null
+++ b/OpenSim/Region/Physics/BulletSPlugin/BSActorHover.cs
@@ -0,0 +1,173 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyrightD
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSimulator Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+using OpenSim.Region.Physics.Manager;
+
+using OMV = OpenMetaverse;
+
+namespace OpenSim.Region.Physics.BulletSPlugin
+{
+public class BSActorHover : BSActor
+{
+    private BSFMotor m_hoverMotor;
+
+    public BSActorHover(BSScene physicsScene, BSPhysObject pObj, string actorName)
+        : base(physicsScene, pObj, actorName)
+    {
+        m_hoverMotor = null;
+        m_physicsScene.DetailLog("{0},BSActorHover,constructor", m_controllingPrim.LocalID);
+    }
+
+    // BSActor.isActive
+    public override bool isActive
+    {
+        get { return Enabled; }
+    }
+
+    // Release any connections and resources used by the actor.
+    // BSActor.Dispose()
+    public override void Dispose()
+    {
+        Enabled = false;
+    }
+
+    // Called when physical parameters (properties set in Bullet) need to be re-applied.
+    // Called at taint-time.
+    // BSActor.Refresh()
+    public override void Refresh()
+    {
+        m_physicsScene.DetailLog("{0},BSActorHover,refresh", m_controllingPrim.LocalID);
+
+        // If not active any more, turn me off
+        if (!m_controllingPrim.HoverActive)
+        {
+            SetEnabled(false);
+        }
+
+        // If the object is physically active, add the hoverer prestep action
+        if (isActive)
+        {
+            ActivateHover();
+        }
+        else
+        {
+            DeactivateHover();
+        }
+    }
+
+    // The object's physical representation is being rebuilt so pick up any physical dependencies (constraints, ...).
+    //     Register a prestep action to restore physical requirements before the next simulation step.
+    // Called at taint-time.
+    // BSActor.RemoveDependencies()
+    public override void RemoveDependencies()
+    {
+        // Nothing to do for the hoverer since it is all software at pre-step action time.
+    }
+
+    // If a hover motor has not been created, create one and start the hovering.
+    private void ActivateHover()
+    {
+        if (m_hoverMotor == null)
+        {
+            // Turning the target on
+            m_hoverMotor = new BSFMotor("BSActorHover",
+                                        m_controllingPrim.HoverTau,               // timeScale
+                                        BSMotor.Infinite,           // decay time scale
+                                        1f                          // efficiency
+            );
+            m_hoverMotor.SetTarget(ComputeCurrentHoverHeight());
+            m_hoverMotor.SetCurrent(m_controllingPrim.RawPosition.Z);
+            m_hoverMotor.PhysicsScene = m_physicsScene; // DEBUG DEBUG so motor will output detail log messages.
+
+            m_physicsScene.BeforeStep += Hoverer;
+        }
+    }
+
+    private void DeactivateHover()
+    {
+        if (m_hoverMotor != null)
+        {
+            m_physicsScene.BeforeStep -= Hoverer;
+            m_hoverMotor = null;
+        }
+    }
+
+    // Called just before the simulation step. Update the vertical position for hoverness.
+    private void Hoverer(float timeStep)
+    {
+        // Don't do hovering while the object is selected.
+        if (!isActive)
+            return;
+
+        m_hoverMotor.SetCurrent(m_controllingPrim.RawPosition.Z);
+        m_hoverMotor.SetTarget(ComputeCurrentHoverHeight());
+        float targetHeight = m_hoverMotor.Step(timeStep);
+
+        // 'targetHeight' is where we'd like the Z of the prim to be at this moment.
+        // Compute the amount of force to push us there.
+        float moveForce = (targetHeight - m_controllingPrim.RawPosition.Z) * m_controllingPrim.RawMass;
+        // Undo anything the object thinks it's doing at the moment
+        moveForce = -m_controllingPrim.RawVelocity.Z * m_controllingPrim.Mass;
+
+        m_physicsScene.PE.ApplyCentralImpulse(m_controllingPrim.PhysBody, new OMV.Vector3(0f, 0f, moveForce));
+        m_physicsScene.DetailLog("{0},BSPrim.Hover,move,targHt={1},moveForce={2},mass={3}",
+                        m_controllingPrim.LocalID, targetHeight, moveForce, m_controllingPrim.RawMass);
+    }
+
+    // Based on current position, determine what we should be hovering at now.
+    // Must recompute often. What if we walked offa cliff>
+    private float ComputeCurrentHoverHeight()
+    {
+        float ret = m_controllingPrim.HoverHeight;
+        float groundHeight = m_physicsScene.TerrainManager.GetTerrainHeightAtXYZ(m_controllingPrim.RawPosition);
+
+        switch (m_controllingPrim.HoverType)
+        {
+            case PIDHoverType.Ground:
+                ret = groundHeight + m_controllingPrim.HoverHeight;
+                break;
+            case PIDHoverType.GroundAndWater:
+                float waterHeight = m_physicsScene.TerrainManager.GetWaterLevelAtXYZ(m_controllingPrim.RawPosition);
+                if (groundHeight > waterHeight)
+                {
+                    ret = groundHeight + m_controllingPrim.HoverHeight;
+                }
+                else
+                {
+                    ret = waterHeight + m_controllingPrim.HoverHeight;
+                }
+                break;
+        }
+        return ret;
+    }
+}
+}
diff --git a/OpenSim/Region/Physics/BulletSPlugin/BSActorLockAxis.cs b/OpenSim/Region/Physics/BulletSPlugin/BSActorLockAxis.cs
new file mode 100755
index 0000000..8b0fdeb
--- /dev/null
+++ b/OpenSim/Region/Physics/BulletSPlugin/BSActorLockAxis.cs
@@ -0,0 +1,187 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyrightD
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSimulator Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+using OMV = OpenMetaverse;
+
+namespace OpenSim.Region.Physics.BulletSPlugin
+{
+public class BSActorLockAxis : BSActor
+{
+    BSConstraint LockAxisConstraint = null;
+
+    public BSActorLockAxis(BSScene physicsScene, BSPhysObject pObj, string actorName)
+        : base(physicsScene, pObj, actorName)
+    {
+        m_physicsScene.DetailLog("{0},BSActorLockAxis,constructor", m_controllingPrim.LocalID);
+        LockAxisConstraint = null;
+    }
+
+    // BSActor.isActive
+    public override bool isActive
+    {
+        get { return Enabled && m_controllingPrim.IsPhysicallyActive; }
+    }
+
+    // Release any connections and resources used by the actor.
+    // BSActor.Dispose()
+    public override void Dispose()
+    {
+        RemoveAxisLockConstraint();
+    }
+
+    // Called when physical parameters (properties set in Bullet) need to be re-applied.
+    // Called at taint-time.
+    // BSActor.Refresh()
+    public override void Refresh()
+    {
+        m_physicsScene.DetailLog("{0},BSActorLockAxis,refresh,lockedAxis={1},enabled={2},pActive={3}",
+                                    m_controllingPrim.LocalID, m_controllingPrim.LockedAngularAxis, Enabled, m_controllingPrim.IsPhysicallyActive);
+        // If all the axis are free, we don't need to exist
+        if (m_controllingPrim.LockedAngularAxis == m_controllingPrim.LockedAxisFree)
+        {
+            Enabled = false;
+        }
+
+        // If the object is physically active, add the axis locking constraint
+        if (isActive)
+        {
+            AddAxisLockConstraint();
+        }
+        else
+        {
+            RemoveAxisLockConstraint();
+        }
+    }
+
+    // The object's physical representation is being rebuilt so pick up any physical dependencies (constraints, ...).
+    //     Register a prestep action to restore physical requirements before the next simulation step.
+    // Called at taint-time.
+    // BSActor.RemoveDependencies()
+    public override void RemoveDependencies()
+    {
+        if (LockAxisConstraint != null)
+        {
+            // If a constraint is set up, remove it from the physical scene
+            RemoveAxisLockConstraint();
+            // Schedule a call before the next simulation step to restore the constraint.
+            m_physicsScene.PostTaintObject("BSActorLockAxis:" + ActorName, m_controllingPrim.LocalID, delegate()
+            {
+                Refresh();
+            });
+        }
+    }
+
+    private void AddAxisLockConstraint()
+    {
+        if (LockAxisConstraint == null)
+        {
+            // Lock that axis by creating a 6DOF constraint that has one end in the world and
+            //    the other in the object.
+            // http://www.bulletphysics.org/Bullet/phpBB3/viewtopic.php?p=20817
+            // http://www.bulletphysics.org/Bullet/phpBB3/viewtopic.php?p=26380
+
+            // Remove any existing axis constraint (just to be sure)
+            RemoveAxisLockConstraint();
+
+            BSConstraint6Dof axisConstrainer = new BSConstraint6Dof(m_physicsScene.World, m_controllingPrim.PhysBody,
+                                OMV.Vector3.Zero, OMV.Quaternion.Identity,
+                                false /* useLinearReferenceFrameB */, true /* disableCollisionsBetweenLinkedBodies */);
+            LockAxisConstraint = axisConstrainer;
+            m_physicsScene.Constraints.AddConstraint(LockAxisConstraint);
+
+            // The constraint is tied to the world and oriented to the prim.
+
+            // Free to move linearly in the region
+            OMV.Vector3 linearLow = OMV.Vector3.Zero;
+            OMV.Vector3 linearHigh = m_physicsScene.TerrainManager.DefaultRegionSize;
+            if (m_controllingPrim.LockedLinearAxis.X != BSPhysObject.FreeAxis)
+            {
+                linearLow.X = m_controllingPrim.RawPosition.X;
+                linearHigh.X = m_controllingPrim.RawPosition.X;
+            }
+            if (m_controllingPrim.LockedLinearAxis.Y != BSPhysObject.FreeAxis)
+            {
+                linearLow.Y = m_controllingPrim.RawPosition.Y;
+                linearHigh.Y = m_controllingPrim.RawPosition.Y;
+            }
+            if (m_controllingPrim.LockedLinearAxis.Z != BSPhysObject.FreeAxis)
+            {
+                linearLow.Z = m_controllingPrim.RawPosition.Z;
+                linearHigh.Z = m_controllingPrim.RawPosition.Z;
+            }
+            axisConstrainer.SetLinearLimits(linearLow, linearHigh);
+
+            // Angular with some axis locked
+            float fPI = (float)Math.PI;
+            OMV.Vector3 angularLow = new OMV.Vector3(-fPI, -fPI, -fPI);
+            OMV.Vector3 angularHigh = new OMV.Vector3(fPI, fPI, fPI);
+            if (m_controllingPrim.LockedAngularAxis.X != BSPhysObject.FreeAxis)
+            {
+                angularLow.X = 0f;
+                angularHigh.X = 0f;
+            }
+            if (m_controllingPrim.LockedAngularAxis.Y != BSPhysObject.FreeAxis)
+            {
+                angularLow.Y = 0f;
+                angularHigh.Y = 0f;
+            }
+            if (m_controllingPrim.LockedAngularAxis.Z != BSPhysObject.FreeAxis)
+            {
+                angularLow.Z = 0f;
+                angularHigh.Z = 0f;
+            }
+            if (!axisConstrainer.SetAngularLimits(angularLow, angularHigh))
+            {
+                m_physicsScene.DetailLog("{0},BSActorLockAxis.AddAxisLockConstraint,failedSetAngularLimits", m_controllingPrim.LocalID);
+            }
+
+            m_physicsScene.DetailLog("{0},BSActorLockAxis.AddAxisLockConstraint,create,linLow={1},linHi={2},angLow={3},angHi={4}",
+                                        m_controllingPrim.LocalID, linearLow, linearHigh, angularLow, angularHigh);
+
+            // Constants from one of the posts mentioned above and used in Bullet's ConstraintDemo.
+            axisConstrainer.TranslationalLimitMotor(true /* enable */, 5.0f, 0.1f);
+
+            axisConstrainer.RecomputeConstraintVariables(m_controllingPrim.RawMass);
+        }
+    }
+
+    private void RemoveAxisLockConstraint()
+    {
+        if (LockAxisConstraint != null)
+        {
+            m_physicsScene.Constraints.RemoveAndDestroyConstraint(LockAxisConstraint);
+            LockAxisConstraint = null;
+            m_physicsScene.DetailLog("{0},BSActorLockAxis.RemoveAxisLockConstraint,destroyingConstraint", m_controllingPrim.LocalID);
+        }
+    }
+}
+}
diff --git a/OpenSim/Region/Physics/BulletSPlugin/BSActorMoveToTarget.cs b/OpenSim/Region/Physics/BulletSPlugin/BSActorMoveToTarget.cs
new file mode 100755
index 0000000..bdf4bc0
--- /dev/null
+++ b/OpenSim/Region/Physics/BulletSPlugin/BSActorMoveToTarget.cs
@@ -0,0 +1,219 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyrightD
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSimulator Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+using OpenSim.Region.Physics.Manager;
+
+using OMV = OpenMetaverse;
+
+namespace OpenSim.Region.Physics.BulletSPlugin
+{
+public class BSActorMoveToTarget : BSActor
+{
+    private BSVMotor m_targetMotor;
+
+    public BSActorMoveToTarget(BSScene physicsScene, BSPhysObject pObj, string actorName)
+        : base(physicsScene, pObj, actorName)
+    {
+        m_targetMotor = null;
+        m_physicsScene.DetailLog("{0},BSActorMoveToTarget,constructor", m_controllingPrim.LocalID);
+    }
+
+    // BSActor.isActive
+    public override bool isActive
+    {
+        // MoveToTarget only works on physical prims
+        get { return Enabled && m_controllingPrim.IsPhysicallyActive; }
+    }
+
+    // Release any connections and resources used by the actor.
+    // BSActor.Dispose()
+    public override void Dispose()
+    {
+        Enabled = false;
+    }
+
+    // Called when physical parameters (properties set in Bullet) need to be re-applied.
+    // Called at taint-time.
+    // BSActor.Refresh()
+    public override void Refresh()
+    {
+        m_physicsScene.DetailLog("{0},BSActorMoveToTarget,refresh,enabled={1},active={2},target={3},tau={4}",
+            m_controllingPrim.LocalID, Enabled, m_controllingPrim.MoveToTargetActive,
+            m_controllingPrim.MoveToTargetTarget, m_controllingPrim.MoveToTargetTau );
+
+        // If not active any more...
+        if (!m_controllingPrim.MoveToTargetActive)
+        {
+            Enabled = false;
+        }
+
+        if (isActive)
+        {
+            ActivateMoveToTarget();
+        }
+        else
+        {
+            DeactivateMoveToTarget();
+        }
+    }
+
+    // The object's physical representation is being rebuilt so pick up any physical dependencies (constraints, ...).
+    //     Register a prestep action to restore physical requirements before the next simulation step.
+    // Called at taint-time.
+    // BSActor.RemoveDependencies()
+    public override void RemoveDependencies()
+    {
+        // Nothing to do for the moveToTarget since it is all software at pre-step action time.
+    }
+
+    // If a hover motor has not been created, create one and start the hovering.
+    private void ActivateMoveToTarget()
+    {
+        if (m_targetMotor == null)
+        {
+            // We're taking over after this.
+            m_controllingPrim.ZeroMotion(true);
+
+            /* Someday use the PID controller
+            m_targetMotor = new BSPIDVMotor("BSActorMoveToTarget-" + m_controllingPrim.LocalID.ToString());
+            m_targetMotor.TimeScale = m_controllingPrim.MoveToTargetTau;
+            m_targetMotor.Efficiency = 1f;
+             */
+            m_targetMotor = new BSVMotor("BSActorMoveToTarget-" + m_controllingPrim.LocalID.ToString(),
+                                        m_controllingPrim.MoveToTargetTau,  // timeScale
+                                        BSMotor.Infinite,                   // decay time scale
+                                        1f                                  // efficiency
+            );
+            m_targetMotor.PhysicsScene = m_physicsScene; // DEBUG DEBUG so motor will output detail log messages.
+            m_targetMotor.SetTarget(m_controllingPrim.MoveToTargetTarget);
+            m_targetMotor.SetCurrent(m_controllingPrim.RawPosition);
+
+            // m_physicsScene.BeforeStep += Mover;
+            m_physicsScene.BeforeStep += Mover2;
+        }
+        else
+        {
+            // If already allocated, make sure the target and other paramters are current
+            m_targetMotor.SetTarget(m_controllingPrim.MoveToTargetTarget);
+            m_targetMotor.SetCurrent(m_controllingPrim.RawPosition);
+        }
+    }
+
+    private void DeactivateMoveToTarget()
+    {
+        if (m_targetMotor != null)
+        {
+            // m_physicsScene.BeforeStep -= Mover;
+            m_physicsScene.BeforeStep -= Mover2;
+            m_targetMotor = null;
+        }
+    }
+
+    // Origional mover that set the objects position to move to the target.
+    // The problem was that gravity would keep trying to push the object down so
+    //    the overall downward velocity would increase to infinity.
+    // Called just before the simulation step.
+    private void Mover(float timeStep)
+    {
+        // Don't do hovering while the object is selected.
+        if (!isActive)
+            return;
+
+        OMV.Vector3 origPosition = m_controllingPrim.RawPosition;     // DEBUG DEBUG (for printout below)
+
+        // 'movePosition' is where we'd like the prim to be at this moment.
+        OMV.Vector3 movePosition = m_controllingPrim.RawPosition + m_targetMotor.Step(timeStep);
+
+        // If we are very close to our target, turn off the movement motor.
+        if (m_targetMotor.ErrorIsZero())
+        {
+            m_physicsScene.DetailLog("{0},BSActorMoveToTarget.Mover,zeroMovement,movePos={1},pos={2},mass={3}",
+                                    m_controllingPrim.LocalID, movePosition, m_controllingPrim.RawPosition, m_controllingPrim.Mass);
+            m_controllingPrim.ForcePosition = m_targetMotor.TargetValue;
+            m_controllingPrim.ForceVelocity = OMV.Vector3.Zero;
+            // Setting the position does not cause the physics engine to generate a property update. Force it.
+            m_physicsScene.PE.PushUpdate(m_controllingPrim.PhysBody);
+        }
+        else
+        {
+            m_controllingPrim.ForcePosition = movePosition;
+            // Setting the position does not cause the physics engine to generate a property update. Force it.
+            m_physicsScene.PE.PushUpdate(m_controllingPrim.PhysBody);
+        }
+        m_physicsScene.DetailLog("{0},BSActorMoveToTarget.Mover,move,fromPos={1},movePos={2}",
+                                        m_controllingPrim.LocalID, origPosition, movePosition);
+    }
+
+    // Version of mover that applies forces to move the physical object to the target.
+    // Also overcomes gravity so the object doesn't just drop to the ground.
+    // Called just before the simulation step.
+    private void Mover2(float timeStep)
+    {
+        // Don't do hovering while the object is selected.
+        if (!isActive)
+            return;
+
+        OMV.Vector3 origPosition = m_controllingPrim.RawPosition;     // DEBUG DEBUG (for printout below)
+        OMV.Vector3 addedForce = OMV.Vector3.Zero;
+
+        // CorrectionVector is the movement vector required this step
+        OMV.Vector3 correctionVector = m_targetMotor.Step(timeStep, m_controllingPrim.RawPosition);
+
+        // If we are very close to our target, turn off the movement motor.
+        if (m_targetMotor.ErrorIsZero())
+        {
+            m_physicsScene.DetailLog("{0},BSActorMoveToTarget.Mover3,zeroMovement,pos={1},mass={2}",
+                                    m_controllingPrim.LocalID, m_controllingPrim.RawPosition, m_controllingPrim.Mass);
+            m_controllingPrim.ForcePosition = m_targetMotor.TargetValue;
+            m_controllingPrim.ForceVelocity = OMV.Vector3.Zero;
+            // Setting the position does not cause the physics engine to generate a property update. Force it.
+            m_physicsScene.PE.PushUpdate(m_controllingPrim.PhysBody);
+        }
+        else
+        {
+            // First force to move us there -- the motor return a timestep scaled value.
+            addedForce = correctionVector / timeStep;
+            // Remove the existing velocity (only the moveToTarget force counts)
+            addedForce -= m_controllingPrim.RawVelocity;
+            // Overcome gravity. 
+            addedForce -= m_controllingPrim.Gravity;
+
+            // Add enough force to overcome the mass of the object
+            addedForce *= m_controllingPrim.Mass;
+
+            m_controllingPrim.AddForce(addedForce, false /* pushForce */, true /* inTaintTime */);
+        }
+        m_physicsScene.DetailLog("{0},BSActorMoveToTarget.Mover3,move,fromPos={1},addedForce={2}",
+                                        m_controllingPrim.LocalID, origPosition, addedForce);
+    }
+}
+}
diff --git a/OpenSim/Region/Physics/BulletSPlugin/BSActorSetForce.cs b/OpenSim/Region/Physics/BulletSPlugin/BSActorSetForce.cs
new file mode 100755
index 0000000..96fa0b6
--- /dev/null
+++ b/OpenSim/Region/Physics/BulletSPlugin/BSActorSetForce.cs
@@ -0,0 +1,137 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyrightD
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSimulator Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+using OpenSim.Region.Physics.Manager;
+
+using OMV = OpenMetaverse;
+
+namespace OpenSim.Region.Physics.BulletSPlugin
+{
+public class BSActorSetForce : BSActor
+{
+    BSFMotor m_forceMotor;
+
+    public BSActorSetForce(BSScene physicsScene, BSPhysObject pObj, string actorName)
+        : base(physicsScene, pObj, actorName)
+    {
+        m_forceMotor = null;
+        m_physicsScene.DetailLog("{0},BSActorSetForce,constructor", m_controllingPrim.LocalID);
+    }
+
+    // BSActor.isActive
+    public override bool isActive
+    {
+        get { return Enabled && m_controllingPrim.IsPhysicallyActive; }
+    }
+
+    // Release any connections and resources used by the actor.
+    // BSActor.Dispose()
+    public override void Dispose()
+    {
+        Enabled = false;
+    }
+
+    // Called when physical parameters (properties set in Bullet) need to be re-applied.
+    // Called at taint-time.
+    // BSActor.Refresh()
+    public override void Refresh()
+    {
+        m_physicsScene.DetailLog("{0},BSActorSetForce,refresh", m_controllingPrim.LocalID);
+
+        // If not active any more, get rid of me (shouldn't ever happen, but just to be safe)
+        if (m_controllingPrim.RawForce == OMV.Vector3.Zero)
+        {
+            m_physicsScene.DetailLog("{0},BSActorSetForce,refresh,notSetForce,removing={1}", m_controllingPrim.LocalID, ActorName);
+            Enabled = false;
+            return;
+        }
+
+        // If the object is physically active, add the hoverer prestep action
+        if (isActive)
+        {
+            ActivateSetForce();
+        }
+        else
+        {
+            DeactivateSetForce();
+        }
+    }
+
+    // The object's physical representation is being rebuilt so pick up any physical dependencies (constraints, ...).
+    //     Register a prestep action to restore physical requirements before the next simulation step.
+    // Called at taint-time.
+    // BSActor.RemoveDependencies()
+    public override void RemoveDependencies()
+    {
+        // Nothing to do for the hoverer since it is all software at pre-step action time.
+    }
+
+    // If a hover motor has not been created, create one and start the hovering.
+    private void ActivateSetForce()
+    {
+        if (m_forceMotor == null)
+        {
+            // A fake motor that might be used someday
+            m_forceMotor = new BSFMotor("setForce", 1f, 1f, 1f);
+
+            m_physicsScene.BeforeStep += Mover;
+        }
+    }
+
+    private void DeactivateSetForce()
+    {
+        if (m_forceMotor != null)
+        {
+            m_physicsScene.BeforeStep -= Mover;
+            m_forceMotor = null;
+        }
+    }
+
+    // Called just before the simulation step. Update the vertical position for hoverness.
+    private void Mover(float timeStep)
+    {
+        // Don't do force while the object is selected.
+        if (!isActive)
+            return;
+
+        m_physicsScene.DetailLog("{0},BSActorSetForce,preStep,force={1}", m_controllingPrim.LocalID, m_controllingPrim.RawForce);
+        if (m_controllingPrim.PhysBody.HasPhysicalBody)
+        {
+            m_physicsScene.PE.ApplyCentralForce(m_controllingPrim.PhysBody, m_controllingPrim.RawForce);
+            m_controllingPrim.ActivateIfPhysical(false);
+        }
+
+        // TODO:
+    }
+}
+}
+
diff --git a/OpenSim/Region/Physics/BulletSPlugin/BSActorSetTorque.cs b/OpenSim/Region/Physics/BulletSPlugin/BSActorSetTorque.cs
new file mode 100755
index 0000000..65098e1
--- /dev/null
+++ b/OpenSim/Region/Physics/BulletSPlugin/BSActorSetTorque.cs
@@ -0,0 +1,138 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyrightD
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSimulator Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+using OpenSim.Region.Physics.Manager;
+
+using OMV = OpenMetaverse;
+
+namespace OpenSim.Region.Physics.BulletSPlugin
+{
+public class BSActorSetTorque : BSActor
+{
+    BSFMotor m_torqueMotor;
+
+    public BSActorSetTorque(BSScene physicsScene, BSPhysObject pObj, string actorName)
+        : base(physicsScene, pObj, actorName)
+    {
+        m_torqueMotor = null;
+        m_physicsScene.DetailLog("{0},BSActorSetTorque,constructor", m_controllingPrim.LocalID);
+    }
+
+    // BSActor.isActive
+    public override bool isActive
+    {
+        get { return Enabled && m_controllingPrim.IsPhysicallyActive; }
+    }
+
+    // Release any connections and resources used by the actor.
+    // BSActor.Dispose()
+    public override void Dispose()
+    {
+        Enabled = false;
+    }
+
+    // Called when physical parameters (properties set in Bullet) need to be re-applied.
+    // Called at taint-time.
+    // BSActor.Refresh()
+    public override void Refresh()
+    {
+        m_physicsScene.DetailLog("{0},BSActorSetTorque,refresh,torque={1}", m_controllingPrim.LocalID, m_controllingPrim.RawTorque);
+
+        // If not active any more, get rid of me (shouldn't ever happen, but just to be safe)
+        if (m_controllingPrim.RawTorque == OMV.Vector3.Zero)
+        {
+            m_physicsScene.DetailLog("{0},BSActorSetTorque,refresh,notSetTorque,disabling={1}", m_controllingPrim.LocalID, ActorName);
+            Enabled = false;
+            return;
+        }
+
+        // If the object is physically active, add the hoverer prestep action
+        if (isActive)
+        {
+            ActivateSetTorque();
+        }
+        else
+        {
+            DeactivateSetTorque();
+        }
+    }
+
+    // The object's physical representation is being rebuilt so pick up any physical dependencies (constraints, ...).
+    //     Register a prestep action to restore physical requirements before the next simulation step.
+    // Called at taint-time.
+    // BSActor.RemoveDependencies()
+    public override void RemoveDependencies()
+    {
+        // Nothing to do for the hoverer since it is all software at pre-step action time.
+    }
+
+    // If a hover motor has not been created, create one and start the hovering.
+    private void ActivateSetTorque()
+    {
+        if (m_torqueMotor == null)
+        {
+            // A fake motor that might be used someday
+            m_torqueMotor = new BSFMotor("setTorque", 1f, 1f, 1f);
+
+            m_physicsScene.BeforeStep += Mover;
+        }
+    }
+
+    private void DeactivateSetTorque()
+    {
+        if (m_torqueMotor != null)
+        {
+            m_physicsScene.BeforeStep -= Mover;
+            m_torqueMotor = null;
+        }
+    }
+
+    // Called just before the simulation step. Update the vertical position for hoverness.
+    private void Mover(float timeStep)
+    {
+        // Don't do force while the object is selected.
+        if (!isActive)
+            return;
+
+        m_physicsScene.DetailLog("{0},BSActorSetTorque,preStep,force={1}", m_controllingPrim.LocalID, m_controllingPrim.RawTorque);
+        if (m_controllingPrim.PhysBody.HasPhysicalBody)
+        {
+            m_controllingPrim.AddAngularForce(m_controllingPrim.RawTorque, false, true);
+            m_controllingPrim.ActivateIfPhysical(false);
+        }
+
+        // TODO:
+    }
+}
+}
+
+
diff --git a/OpenSim/Region/Physics/BulletSPlugin/BSActors.cs b/OpenSim/Region/Physics/BulletSPlugin/BSActors.cs
new file mode 100755
index 0000000..e0ccc50
--- /dev/null
+++ b/OpenSim/Region/Physics/BulletSPlugin/BSActors.cs
@@ -0,0 +1,156 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyrightD
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSimulator Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace OpenSim.Region.Physics.BulletSPlugin
+{
+public class BSActorCollection
+{
+    private BSScene m_physicsScene { get; set; }
+    private Dictionary<string, BSActor> m_actors;
+
+    public BSActorCollection(BSScene physicsScene)
+    {
+        m_physicsScene = physicsScene;
+        m_actors = new Dictionary<string, BSActor>();
+    }
+    public void Add(string name, BSActor actor)
+    {
+        lock (m_actors)
+        {
+            if (!m_actors.ContainsKey(name))
+            {
+                m_actors[name] = actor;
+            }
+        }
+    }
+    public bool RemoveAndRelease(string name)
+    {
+        bool ret = false;
+        lock (m_actors)
+        {
+            if (m_actors.ContainsKey(name))
+            {
+                BSActor beingRemoved = m_actors[name];
+                m_actors.Remove(name);
+                beingRemoved.Dispose();
+                ret = true;
+            }
+        }
+        return ret;
+    }
+    public void Clear()
+    {
+        lock (m_actors)
+        {
+            ForEachActor(a => a.Dispose());
+            m_actors.Clear();
+        }
+    }
+    public void Dispose()
+    {
+        Clear();
+    }
+    public bool HasActor(string name)
+    {
+        return m_actors.ContainsKey(name);
+    }
+    public bool TryGetActor(string actorName, out BSActor theActor)
+    {
+        return m_actors.TryGetValue(actorName, out theActor);
+    }
+    public void ForEachActor(Action<BSActor> act)
+    {
+        lock (m_actors)
+        {
+            foreach (KeyValuePair<string, BSActor> kvp in m_actors)
+                act(kvp.Value);
+        }
+    }
+
+    public void Enable(bool enabl)
+    {
+        ForEachActor(a => a.SetEnabled(enabl));
+    }
+    public void Refresh()
+    {
+        ForEachActor(a => a.Refresh());
+    }
+    public void RemoveDependencies()
+    {
+        ForEachActor(a => a.RemoveDependencies());
+    }
+}
+
+// =============================================================================
+/// <summary>
+/// Each physical object can have 'actors' who are pushing the object around.
+/// This can be used for hover, locking axis, making vehicles, etc.
+/// Each physical object can have multiple actors acting on it.
+///
+/// An actor usually registers itself with physics scene events (pre-step action)
+/// and modifies the parameters on the host physical object.
+/// </summary>
+public abstract class BSActor
+{
+    protected BSScene m_physicsScene { get; private set; }
+    protected BSPhysObject m_controllingPrim { get; private set; }
+    public virtual bool Enabled { get; set; }
+    public string ActorName { get; private set; }
+
+    public BSActor(BSScene physicsScene, BSPhysObject pObj, string actorName)
+    {
+        m_physicsScene = physicsScene;
+        m_controllingPrim = pObj;
+        ActorName = actorName;
+        Enabled = true;
+    }
+
+    // Return 'true' if activily updating the prim
+    public virtual bool isActive
+    {
+        get { return Enabled; }
+    }
+
+    // Turn the actor on an off. Only used by ActorCollection to set all enabled/disabled.
+    // Anyone else should assign true/false to 'Enabled'.
+    public void SetEnabled(bool setEnabled)
+    {
+        Enabled = setEnabled;
+    }
+    // Release any connections and resources used by the actor.
+    public abstract void Dispose();
+    // Called when physical parameters (properties set in Bullet) need to be re-applied.
+    public abstract void Refresh();
+    // The object's physical representation is being rebuilt so pick up any physical dependencies (constraints, ...).
+    //     Register a prestep action to restore physical requirements before the next simulation step.
+    public abstract void RemoveDependencies();
+
+}
+}
diff --git a/OpenSim/Region/Physics/BulletSPlugin/BSApiTemplate.cs b/OpenSim/Region/Physics/BulletSPlugin/BSApiTemplate.cs
index 5765b0d..be6f152 100644
--- a/OpenSim/Region/Physics/BulletSPlugin/BSApiTemplate.cs
+++ b/OpenSim/Region/Physics/BulletSPlugin/BSApiTemplate.cs
@@ -43,7 +43,9 @@ public enum ConstraintType : int
         SLIDER_CONSTRAINT_TYPE,
         CONTACT_CONSTRAINT_TYPE,
         D6_SPRING_CONSTRAINT_TYPE,
-        MAX_CONSTRAINT_TYPE
+        MAX_CONSTRAINT_TYPE,            // last type defined by Bullet
+    //
+    FIXED_CONSTRAINT_TYPE = 1234    // BulletSim constraint that is fixed and unmoving
 }
 
 // ===============================================================================
@@ -70,6 +72,8 @@ public enum BSPhysicsShapeType
         SHAPE_COMPOUND  = 22,
         SHAPE_HEIGHTMAP = 23,
     SHAPE_AVATAR    = 24,
+    SHAPE_CONVEXHULL= 25,
+    SHAPE_GIMPACT   = 26,
 };
 
 // The native shapes have predefined shape hash keys
@@ -191,6 +195,21 @@ public struct ConfigurationParameters
     public const float numericFalse = 0f;
 }
 
+// Parameters passed for the conversion of a mesh to a hull using Bullet's HACD library.
+[StructLayout(LayoutKind.Sequential)]
+public struct HACDParams
+{
+                                            // usual default values
+        public float maxVerticesPerHull;                // 100
+        public float minClusters;                               // 2
+        public float compacityWeight;                   // 0.1
+        public float volumeWeight;                              // 0.0
+        public float concavity;                             // 100
+        public float addExtraDistPoints;                // false
+        public float addNeighboursDistPoints;   // false
+        public float addFacesPoints;                    // false
+        public float shouldAdjustCollisionMargin;       // false
+}
 
 // The states a bullet collision object can have
 public enum ActivationState : uint
@@ -230,7 +249,7 @@ public enum CollisionFlags : uint
     BS_VEHICLE_COLLISIONS            = 1 << 12, // return collisions for vehicle ground checking
     BS_RETURN_ROOT_COMPOUND_SHAPE    = 1 << 13, // return the pos/rot of the root shape in a compound shape
     BS_NONE                          = 0,
-    BS_ALL                           = 0xFFFFFFFF
+    BS_ALL                           = 0x7FFF   // collision flags are a signed short
 };
 
 // Values f collisions groups and masks
@@ -246,14 +265,14 @@ public enum CollisionFilterGroups : uint
     BDebrisGroup            = 1 << 3,   // 0008
     BSensorTrigger          = 1 << 4,   // 0010
     BCharacterGroup         = 1 << 5,   // 0020
-    BAllGroup               = 0x000FFFFF,
+    BAllGroup               = 0x0007FFF,        // collision flags are a signed short
     // Filter groups defined by BulletSim
-    BGroundPlaneGroup       = 1 << 10,  // 0400
-    BTerrainGroup           = 1 << 11,  // 0800
-    BRaycastGroup           = 1 << 12,  // 1000
-    BSolidGroup             = 1 << 13,  // 2000
+    BGroundPlaneGroup       = 1 << 8,  // 0400
+    BTerrainGroup           = 1 << 9,  // 0800
+    BRaycastGroup           = 1 << 10,  // 1000
+    BSolidGroup             = 1 << 11,  // 2000
     // BLinksetGroup        = xx  // a linkset proper is either static or dynamic
-    BLinksetChildGroup      = 1 << 14,  // 4000
+    BLinksetChildGroup      = 1 << 12,  // 4000
 };
 
 // CFM controls the 'hardness' of the constraint. 0=fixed, 0..1=violatable. Default=0
@@ -273,7 +292,7 @@ public enum ConstraintParamAxis : int
     AXIS_ANGULAR_X,
     AXIS_ANGULAR_Y,
     AXIS_ANGULAR_Z,
-    AXIS_LINEAR_ALL = 20,    // these last three added by BulletSim so we don't have to do zillions of calls
+    AXIS_LINEAR_ALL = 20,    // added by BulletSim so we don't have to do zillions of calls
     AXIS_ANGULAR_ALL,
     AXIS_ALL
 };
@@ -282,7 +301,7 @@ public abstract class BSAPITemplate
 {
 // Returns the name of the underlying Bullet engine
 public abstract string BulletEngineName { get; }
-public abstract string BulletEngineVersion { get; protected set;} 
+public abstract string BulletEngineVersion { get; protected set;}
 
 // Initialization and simulation
 public abstract BulletWorld Initialize(Vector3 maxPosition, ConfigurationParameters parms,
@@ -305,10 +324,20 @@ public abstract BulletShape CreateMeshShape(BulletWorld world,
                 int indicesCount, int[] indices,
                 int verticesCount, float[] vertices );
 
+public abstract BulletShape CreateGImpactShape(BulletWorld world,
+                int indicesCount, int[] indices,
+                int verticesCount, float[] vertices );
+
 public abstract BulletShape CreateHullShape(BulletWorld world,
                 int hullCount, float[] hulls);
 
-public abstract BulletShape BuildHullShapeFromMesh(BulletWorld world, BulletShape meshShape);
+public abstract BulletShape BuildHullShapeFromMesh(BulletWorld world, BulletShape meshShape, HACDParams parms);
+
+public abstract BulletShape BuildConvexHullShapeFromMesh(BulletWorld world, BulletShape meshShape);
+
+public abstract BulletShape CreateConvexHullShape(BulletWorld world,
+                int indicesCount, int[] indices,
+                int verticesCount, float[] vertices );
 
 public abstract BulletShape BuildNativeShape(BulletWorld world, ShapeData shapeData);
 
@@ -351,7 +380,7 @@ public abstract void DestroyObject(BulletWorld sim, BulletBody obj);
 // =====================================================================================
 public abstract BulletShape CreateGroundPlaneShape(UInt32 id, float height, float collisionMargin);
 
-public abstract BulletShape CreateTerrainShape(UInt32 id, Vector3 size, float minHeight, float maxHeight, float[] heightMap, 
+public abstract BulletShape CreateTerrainShape(UInt32 id, Vector3 size, float minHeight, float maxHeight, float[] heightMap,
                                                                 float scaleFactor, float collisionMargin);
 
 // =====================================================================================
@@ -366,7 +395,7 @@ public abstract BulletConstraint Create6DofConstraintToPoint(BulletWorld world,
                     bool useLinearReferenceFrameA, bool disableCollisionsBetweenLinkedBodies);
 
 public abstract BulletConstraint Create6DofConstraintFixed(BulletWorld world, BulletBody obj1,
-                    Vector3 frameInBloc, Quaternion frameInBrot, 
+                    Vector3 frameInBloc, Quaternion frameInBrot,
                     bool useLinearReferenceFrameB, bool disableCollisionsBetweenLinkedBodies);
 
 public abstract BulletConstraint Create6DofSpringConstraint(BulletWorld world, BulletBody obj1, BulletBody obj2,
@@ -414,6 +443,38 @@ public abstract bool TranslationalLimitMotor(BulletConstraint constrain, float e
 
 public abstract bool SetBreakingImpulseThreshold(BulletConstraint constrain, float threshold);
 
+public const int HINGE_NOT_SPECIFIED = -1;
+public abstract bool HingeSetLimits(BulletConstraint constrain, float low, float high, float softness, float bias, float relaxation);
+
+public abstract bool SpringEnable(BulletConstraint constrain, int index, float numericTrueFalse);
+
+public const int SPRING_NOT_SPECIFIED = -1;
+public abstract bool SpringSetEquilibriumPoint(BulletConstraint constrain, int index, float equilibriumPoint);
+
+public abstract bool SpringSetStiffness(BulletConstraint constrain, int index, float stiffnesss);
+
+public abstract bool SpringSetDamping(BulletConstraint constrain, int index, float damping);
+
+public const int SLIDER_LOWER_LIMIT = 0;
+public const int SLIDER_UPPER_LIMIT = 1;
+public const int SLIDER_LINEAR = 2;
+public const int SLIDER_ANGULAR = 3;
+public abstract bool SliderSetLimits(BulletConstraint constrain, int lowerUpper, int linAng, float val);
+
+public const int SLIDER_SET_SOFTNESS = 4;
+public const int SLIDER_SET_RESTITUTION = 5;
+public const int SLIDER_SET_DAMPING = 6;
+public const int SLIDER_SET_DIRECTION = 7;
+public const int SLIDER_SET_LIMIT = 8;
+public const int SLIDER_SET_ORTHO = 9;
+public abstract bool SliderSet(BulletConstraint constrain, int softRestDamp, int dirLimOrtho, int linAng, float val);
+
+public abstract bool SliderMotorEnable(BulletConstraint constrain, int linAng, float numericTrueFalse);
+
+public const int SLIDER_MOTOR_VELOCITY = 10;
+public const int SLIDER_MAX_MOTOR_FORCE = 11;
+public abstract bool SliderMotor(BulletConstraint constrain, int forceVel, int linAng, float val);
+
 public abstract bool CalculateTransforms(BulletConstraint constrain);
 
 public abstract bool SetConstraintParam(BulletConstraint constrain, ConstraintParams paramIndex, float value, ConstraintParamAxis axis);
@@ -437,6 +498,8 @@ public abstract bool AddObjectToWorld(BulletWorld world, BulletBody obj);
 
 public abstract bool RemoveObjectFromWorld(BulletWorld world, BulletBody obj);
 
+public abstract bool ClearCollisionProxyCache(BulletWorld world, BulletBody obj);
+
 public abstract bool AddConstraintToWorld(BulletWorld world, BulletConstraint constrain, bool disableCollisionsBetweenLinkedObjects);
 
 public abstract bool RemoveConstraintFromWorld(BulletWorld world, BulletConstraint constrain);
diff --git a/OpenSim/Region/Physics/BulletSPlugin/BSCharacter.cs b/OpenSim/Region/Physics/BulletSPlugin/BSCharacter.cs
index 90c2d9c..fc18960 100644
--- a/OpenSim/Region/Physics/BulletSPlugin/BSCharacter.cs
+++ b/OpenSim/Region/Physics/BulletSPlugin/BSCharacter.cs
@@ -1,4 +1,4 @@
-/*
+/*
  * Copyright (c) Contributors, http://opensimulator.org/
  * See CONTRIBUTORS.TXT for a full list of copyright holders.
  *
@@ -43,15 +43,10 @@ public sealed class BSCharacter : BSPhysObject
     private OMV.Vector3 _size;
     private bool _grabbed;
     private bool _selected;
-    private OMV.Vector3 _position;
     private float _mass;
     private float _avatarVolume;
-    private OMV.Vector3 _force;
-    private OMV.Vector3 _velocity;
-    private OMV.Vector3 _torque;
     private float _collisionScore;
     private OMV.Vector3 _acceleration;
-    private OMV.Quaternion _orientation;
     private int _physicsActorType;
     private bool _isPhysical;
     private bool _flying;
@@ -62,28 +57,25 @@ public sealed class BSCharacter : BSPhysObject
     private bool _kinematic;
     private float _buoyancy;
 
-    private BSVMotor _velocityMotor;
+    private BSActorAvatarMove m_moveActor;
+    private const string AvatarMoveActorName = "BSCharacter.AvatarMove";
 
     private OMV.Vector3 _PIDTarget;
     private bool _usePID;
     private float _PIDTau;
-    private bool _useHoverPID;
-    private float _PIDHoverHeight;
-    private PIDHoverType _PIDHoverType;
-    private float _PIDHoverTao;
 
     public BSCharacter(uint localID, String avName, BSScene parent_scene, OMV.Vector3 pos, OMV.Vector3 size, bool isFlying)
             : base(parent_scene, localID, avName, "BSCharacter")
     {
         _physicsActorType = (int)ActorTypes.Agent;
-        _position = pos;
+        RawPosition = pos;
 
         _flying = isFlying;
-        _orientation = OMV.Quaternion.Identity;
-        _velocity = OMV.Vector3.Zero;
+        RawOrientation = OMV.Quaternion.Identity;
+        RawVelocity = OMV.Vector3.Zero;
         _buoyancy = ComputeBuoyancyFromFlying(isFlying);
         Friction = BSParam.AvatarStandingFriction;
-        Density = BSParam.AvatarDensity / BSParam.DensityScaleFactor;
+        Density = BSParam.AvatarDensity;
 
         // Old versions of ScenePresence passed only the height. If width and/or depth are zero,
         //     replace with the default values.
@@ -97,19 +89,26 @@ public sealed class BSCharacter : BSPhysObject
         // set _avatarVolume and _mass based on capsule size, _density and Scale
         ComputeAvatarVolumeAndMass();
 
-        SetupMovementMotor();
-
-        DetailLog("{0},BSCharacter.create,call,size={1},scale={2},density={3},volume={4},mass={5}",
-                            LocalID, _size, Scale, Density, _avatarVolume, RawMass);
+        DetailLog("{0},BSCharacter.create,call,size={1},scale={2},density={3},volume={4},mass={5},pos={6}",
+                            LocalID, _size, Scale, Density, _avatarVolume, RawMass, pos);
 
         // do actual creation in taint time
-        PhysicsScene.TaintedObject("BSCharacter.create", delegate()
+        PhysScene.TaintedObject(LocalID, "BSCharacter.create", delegate()
         {
             DetailLog("{0},BSCharacter.create,taint", LocalID);
             // New body and shape into PhysBody and PhysShape
-            PhysicsScene.Shapes.GetBodyAndShape(true, PhysicsScene.World, this);
+            PhysScene.Shapes.GetBodyAndShape(true, PhysScene.World, this);
+
+            // The avatar's movement is controlled by this motor that speeds up and slows down
+            //    the avatar seeking to reach the motor's target speed.
+            // This motor runs as a prestep action for the avatar so it will keep the avatar
+            //    standing as well as moving. Destruction of the avatar will destroy the pre-step action.
+            m_moveActor = new BSActorAvatarMove(PhysScene, this, AvatarMoveActorName);
+            PhysicalActors.Add(AvatarMoveActorName, m_moveActor);
 
             SetPhysicalProperties();
+
+            IsInitialized = true;
         });
         return;
     }
@@ -117,217 +116,68 @@ public sealed class BSCharacter : BSPhysObject
     // called when this character is being destroyed and the resources should be released
     public override void Destroy()
     {
+        IsInitialized = false;
+
         base.Destroy();
 
         DetailLog("{0},BSCharacter.Destroy", LocalID);
-        PhysicsScene.TaintedObject("BSCharacter.destroy", delegate()
+        PhysScene.TaintedObject(LocalID, "BSCharacter.destroy", delegate()
         {
-            PhysicsScene.Shapes.DereferenceBody(PhysBody, null /* bodyCallback */);
+            PhysScene.Shapes.DereferenceBody(PhysBody, null /* bodyCallback */);
             PhysBody.Clear();
-            PhysicsScene.Shapes.DereferenceShape(PhysShape, null /* bodyCallback */);
-            PhysShape.Clear();
+            PhysShape.Dereference(PhysScene);
+            PhysShape = new BSShapeNull();
         });
     }
 
     private void SetPhysicalProperties()
     {
-        PhysicsScene.PE.RemoveObjectFromWorld(PhysicsScene.World, PhysBody);
+        PhysScene.PE.RemoveObjectFromWorld(PhysScene.World, PhysBody);
 
         ZeroMotion(true);
-        ForcePosition = _position;
+        ForcePosition = RawPosition;
 
         // Set the velocity
-        _velocityMotor.Reset();
-        _velocityMotor.SetTarget(_velocity);
-        _velocityMotor.SetCurrent(_velocity);
-        ForceVelocity = _velocity;
+        if (m_moveActor != null)
+            m_moveActor.SetVelocityAndTarget(RawVelocity, RawVelocity, false);
+
+        ForceVelocity = RawVelocity;
 
         // This will enable or disable the flying buoyancy of the avatar.
         // Needs to be reset especially when an avatar is recreated after crossing a region boundry.
         Flying = _flying;
 
-        PhysicsScene.PE.SetRestitution(PhysBody, BSParam.AvatarRestitution);
-        PhysicsScene.PE.SetMargin(PhysShape, PhysicsScene.Params.collisionMargin);
-        PhysicsScene.PE.SetLocalScaling(PhysShape, Scale);
-        PhysicsScene.PE.SetContactProcessingThreshold(PhysBody, BSParam.ContactProcessingThreshold);
+        PhysScene.PE.SetRestitution(PhysBody, BSParam.AvatarRestitution);
+        PhysScene.PE.SetMargin(PhysShape.physShapeInfo, PhysScene.Params.collisionMargin);
+        PhysScene.PE.SetLocalScaling(PhysShape.physShapeInfo, Scale);
+        PhysScene.PE.SetContactProcessingThreshold(PhysBody, BSParam.ContactProcessingThreshold);
         if (BSParam.CcdMotionThreshold > 0f)
         {
-            PhysicsScene.PE.SetCcdMotionThreshold(PhysBody, BSParam.CcdMotionThreshold);
-            PhysicsScene.PE.SetCcdSweptSphereRadius(PhysBody, BSParam.CcdSweptSphereRadius);
+            PhysScene.PE.SetCcdMotionThreshold(PhysBody, BSParam.CcdMotionThreshold);
+            PhysScene.PE.SetCcdSweptSphereRadius(PhysBody, BSParam.CcdSweptSphereRadius);
         }
 
         UpdatePhysicalMassProperties(RawMass, false);
 
         // Make so capsule does not fall over
-        PhysicsScene.PE.SetAngularFactorV(PhysBody, OMV.Vector3.Zero);
+        PhysScene.PE.SetAngularFactorV(PhysBody, OMV.Vector3.Zero);
+
+        // The avatar mover sets some parameters.
+        PhysicalActors.Refresh();
 
-        PhysicsScene.PE.AddToCollisionFlags(PhysBody, CollisionFlags.CF_CHARACTER_OBJECT);
+        PhysScene.PE.AddToCollisionFlags(PhysBody, CollisionFlags.CF_CHARACTER_OBJECT);
 
-        PhysicsScene.PE.AddObjectToWorld(PhysicsScene.World, PhysBody);
+        PhysScene.PE.AddObjectToWorld(PhysScene.World, PhysBody);
 
         // PhysicsScene.PE.ForceActivationState(PhysBody, ActivationState.ACTIVE_TAG);
-        PhysicsScene.PE.ForceActivationState(PhysBody, ActivationState.DISABLE_DEACTIVATION);
-        PhysicsScene.PE.UpdateSingleAabb(PhysicsScene.World, PhysBody);
+        PhysScene.PE.ForceActivationState(PhysBody, ActivationState.DISABLE_DEACTIVATION);
+        PhysScene.PE.UpdateSingleAabb(PhysScene.World, PhysBody);
 
         // Do this after the object has been added to the world
         PhysBody.collisionType = CollisionType.Avatar;
-        PhysBody.ApplyCollisionMask(PhysicsScene);
-    }
-
-    // The avatar's movement is controlled by this motor that speeds up and slows down
-    //    the avatar seeking to reach the motor's target speed.
-    // This motor runs as a prestep action for the avatar so it will keep the avatar
-    //    standing as well as moving. Destruction of the avatar will destroy the pre-step action.
-    private void SetupMovementMotor()
-    {
-        // Infinite decay and timescale values so motor only changes current to target values.
-        _velocityMotor = new BSVMotor("BSCharacter.Velocity", 
-                                            0.2f,                       // time scale
-                                            BSMotor.Infinite,           // decay time scale
-                                            BSMotor.InfiniteVector,     // friction timescale
-                                            1f                          // efficiency
-        );
-        // _velocityMotor.PhysicsScene = PhysicsScene; // DEBUG DEBUG so motor will output detail log messages.
-
-        RegisterPreStepAction("BSCharactor.Movement", LocalID, delegate(float timeStep)
-        {
-            // TODO: Decide if the step parameters should be changed depending on the avatar's
-            //     state (flying, colliding, ...). There is code in ODE to do this.
-
-            // COMMENTARY: when the user is making the avatar walk, except for falling, the velocity
-            //   specified for the avatar is the one that should be used. For falling, if the avatar
-            //   is not flying and is not colliding then it is presumed to be falling and the Z
-            //   component is not fooled with (thus allowing gravity to do its thing).
-            // When the avatar is standing, though, the user has specified a velocity of zero and
-            //   the avatar should be standing. But if the avatar is pushed by something in the world
-            //   (raising elevator platform, moving vehicle, ...) the avatar should be allowed to
-            //   move. Thus, the velocity cannot be forced to zero. The problem is that small velocity
-            //   errors can creap in and the avatar will slowly float off in some direction.
-            // So, the problem is that, when an avatar is standing, we cannot tell creaping error
-            //   from real pushing.
-            // The code below uses whether the collider is static or moving to decide whether to zero motion.
-
-            _velocityMotor.Step(timeStep);
-
-            // If we're not supposed to be moving, make sure things are zero.
-            if (_velocityMotor.ErrorIsZero() && _velocityMotor.TargetValue == OMV.Vector3.Zero)
-            {
-                // The avatar shouldn't be moving
-                _velocityMotor.Zero();
-
-                if (IsColliding)
-                {
-                    // If we are colliding with a stationary object, presume we're standing and don't move around
-                    if (!ColliderIsMoving)
-                    {
-                        DetailLog("{0},BSCharacter.MoveMotor,collidingWithStationary,zeroingMotion", LocalID);
-                        ZeroMotion(true /* inTaintTime */);
-                    }
-
-                    // Standing has more friction on the ground
-                    if (Friction != BSParam.AvatarStandingFriction)
-                    {
-                        Friction = BSParam.AvatarStandingFriction;
-                        PhysicsScene.PE.SetFriction(PhysBody, Friction);
-                    }
-                }
-                else
-                {
-                    if (Flying)
-                    {
-                        // Flying and not collising and velocity nearly zero.
-                        ZeroMotion(true /* inTaintTime */);
-                    }
-                }
-
-                DetailLog("{0},BSCharacter.MoveMotor,taint,stopping,target={1},colliding={2}", LocalID, _velocityMotor.TargetValue, IsColliding);
-            }
-            else
-            {
-                // Supposed to be moving.
-                OMV.Vector3 stepVelocity = _velocityMotor.CurrentValue;
-
-                if (Friction != BSParam.AvatarFriction)
-                {
-                    // Probably starting up walking. Set friction to moving friction.
-                    Friction = BSParam.AvatarFriction;
-                    PhysicsScene.PE.SetFriction(PhysBody, Friction);
-                }
-
-                // If falling, we keep the world's downward vector no matter what the other axis specify.
-                // The check for _velocity.Z < 0 makes jumping work (temporary upward force).
-                if (!Flying && !IsColliding)
-                {
-                    if (_velocity.Z < 0)
-                        stepVelocity.Z = _velocity.Z;
-                    // DetailLog("{0},BSCharacter.MoveMotor,taint,overrideStepZWithWorldZ,stepVel={1}", LocalID, stepVelocity);
-                }
-
-                // 'stepVelocity' is now the speed we'd like the avatar to move in. Turn that into an instantanous force.
-                OMV.Vector3 moveForce = (stepVelocity - _velocity) * Mass;
-
-                // Should we check for move force being small and forcing velocity to zero?
-
-                // Add special movement force to allow avatars to walk up stepped surfaces.
-                moveForce += WalkUpStairs();
-
-                DetailLog("{0},BSCharacter.MoveMotor,move,stepVel={1},vel={2},mass={3},moveForce={4}", LocalID, stepVelocity, _velocity, Mass, moveForce);
-                PhysicsScene.PE.ApplyCentralImpulse(PhysBody, moveForce);
-            }
-        });
+        PhysBody.ApplyCollisionMask(PhysScene);
     }
 
-    // Decide if the character is colliding with a low object and compute a force to pop the
-    //    avatar up so it can walk up and over the low objects.
-    private OMV.Vector3 WalkUpStairs()
-    {
-        OMV.Vector3 ret = OMV.Vector3.Zero;
-
-        // This test is done if moving forward, not flying and is colliding with something.
-        // DetailLog("{0},BSCharacter.WalkUpStairs,IsColliding={1},flying={2},targSpeed={3},collisions={4}",
-        //                 LocalID, IsColliding, Flying, TargetSpeed, CollisionsLastTick.Count);
-        if (IsColliding && !Flying && TargetVelocitySpeed > 0.1f /* && ForwardSpeed < 0.1f */)
-        {
-            // The range near the character's feet where we will consider stairs
-            float nearFeetHeightMin = RawPosition.Z - (Size.Z / 2f) + 0.05f;
-            float nearFeetHeightMax = nearFeetHeightMin + BSParam.AvatarStepHeight;
-
-            // Look for a collision point that is near the character's feet and is oriented the same as the charactor is
-            foreach (KeyValuePair<uint, ContactPoint> kvp in CollisionsLastTick.m_objCollisionList)
-            {
-                // Don't care about collisions with the terrain
-                if (kvp.Key > PhysicsScene.TerrainManager.HighestTerrainID)
-                {
-                    OMV.Vector3 touchPosition = kvp.Value.Position;
-                    // DetailLog("{0},BSCharacter.WalkUpStairs,min={1},max={2},touch={3}",
-                    //                 LocalID, nearFeetHeightMin, nearFeetHeightMax, touchPosition);
-                    if (touchPosition.Z >= nearFeetHeightMin && touchPosition.Z <= nearFeetHeightMax)
-                    {
-                        // This contact is within the 'near the feet' range.
-                        // The normal should be our contact point to the object so it is pointing away
-                        //    thus the difference between our facing orientation and the normal should be small.
-                        OMV.Vector3 directionFacing = OMV.Vector3.UnitX * RawOrientation;
-                        OMV.Vector3 touchNormal = OMV.Vector3.Normalize(kvp.Value.SurfaceNormal);
-                        float diff = Math.Abs(OMV.Vector3.Distance(directionFacing, touchNormal));
-                        if (diff < BSParam.AvatarStepApproachFactor)
-                        {
-                            // Found the stairs contact point. Push up a little to raise the character.
-                            float upForce = (touchPosition.Z - nearFeetHeightMin) * Mass * BSParam.AvatarStepForceFactor;
-                            ret = new OMV.Vector3(0f, 0f, upForce);
-
-                            // Also move the avatar up for the new height
-                            OMV.Vector3 displacement = new OMV.Vector3(0f, 0f, BSParam.AvatarStepHeight / 2f);
-                            ForcePosition = RawPosition + displacement;
-                        }
-                        DetailLog("{0},BSCharacter.WalkUpStairs,touchPos={1},nearFeetMin={2},faceDir={3},norm={4},diff={5},ret={6}",
-                                LocalID, touchPosition, nearFeetHeightMin, directionFacing, touchNormal, diff, ret);
-                    }
-                }
-            }
-        }
-
-        return ret;
-    }
 
     public override void RequestPhysicsterseUpdate()
     {
@@ -344,6 +194,10 @@ public sealed class BSCharacter : BSPhysObject
         }
 
         set {
+            // This is how much the avatar size is changing. Positive means getting bigger.
+            // The avatar altitude must be adjusted for this change.
+            float heightChange = value.Z - _size.Z;
+
             _size = value;
             // Old versions of ScenePresence passed only the height. If width and/or depth are zero,
             //     replace with the default values.
@@ -355,14 +209,18 @@ public sealed class BSCharacter : BSPhysObject
             DetailLog("{0},BSCharacter.setSize,call,size={1},scale={2},density={3},volume={4},mass={5}",
                             LocalID, _size, Scale, Density, _avatarVolume, RawMass);
 
-            PhysicsScene.TaintedObject("BSCharacter.setSize", delegate()
+            PhysScene.TaintedObject(LocalID, "BSCharacter.setSize", delegate()
             {
-                if (PhysBody.HasPhysicalBody && PhysShape.HasPhysicalShape)
+                if (PhysBody.HasPhysicalBody && PhysShape.physShapeInfo.HasPhysicalShape)
                 {
-                    PhysicsScene.PE.SetLocalScaling(PhysShape, Scale);
+                    PhysScene.PE.SetLocalScaling(PhysShape.physShapeInfo, Scale);
                     UpdatePhysicalMassProperties(RawMass, true);
+
+                    // Adjust the avatar's position to account for the increase/decrease in size
+                    ForcePosition = new OMV.Vector3(RawPosition.X, RawPosition.Y, RawPosition.Z + heightChange / 2f);
+
                     // Make sure this change appears as a property update event
-                    PhysicsScene.PE.PushUpdate(PhysBody);
+                    PhysScene.PE.PushUpdate(PhysBody);
                 }
             });
 
@@ -373,11 +231,6 @@ public sealed class BSCharacter : BSPhysObject
     {
         set { BaseShape = value; }
     }
-    // I want the physics engine to make an avatar capsule
-    public override BSPhysicsShapeType PreferredPhysicalShape
-    {
-        get {return BSPhysicsShapeType.SHAPE_CAPSULE; }
-    }
 
     public override bool Grabbed {
         set { _grabbed = value; }
@@ -399,29 +252,29 @@ public sealed class BSCharacter : BSPhysObject
     // Called at taint time!
     public override void ZeroMotion(bool inTaintTime)
     {
-        _velocity = OMV.Vector3.Zero;
+        RawVelocity = OMV.Vector3.Zero;
         _acceleration = OMV.Vector3.Zero;
         _rotationalVelocity = OMV.Vector3.Zero;
 
         // Zero some other properties directly into the physics engine
-        PhysicsScene.TaintedObject(inTaintTime, "BSCharacter.ZeroMotion", delegate()
+        PhysScene.TaintedObject(inTaintTime, LocalID, "BSCharacter.ZeroMotion", delegate()
         {
             if (PhysBody.HasPhysicalBody)
-                PhysicsScene.PE.ClearAllForces(PhysBody);
+                PhysScene.PE.ClearAllForces(PhysBody);
         });
     }
     public override void ZeroAngularMotion(bool inTaintTime)
     {
         _rotationalVelocity = OMV.Vector3.Zero;
 
-        PhysicsScene.TaintedObject(inTaintTime, "BSCharacter.ZeroMotion", delegate()
+        PhysScene.TaintedObject(inTaintTime, LocalID, "BSCharacter.ZeroMotion", delegate()
         {
             if (PhysBody.HasPhysicalBody)
             {
-                PhysicsScene.PE.SetInterpolationAngularVelocity(PhysBody, OMV.Vector3.Zero);
-                PhysicsScene.PE.SetAngularVelocity(PhysBody, OMV.Vector3.Zero);
+                PhysScene.PE.SetInterpolationAngularVelocity(PhysBody, OMV.Vector3.Zero);
+                PhysScene.PE.SetAngularVelocity(PhysBody, OMV.Vector3.Zero);
                 // The next also get rid of applied linear force but the linear velocity is untouched.
-                PhysicsScene.PE.ClearForces(PhysBody);
+                PhysScene.PE.ClearForces(PhysBody);
             }
         });
     }
@@ -429,38 +282,33 @@ public sealed class BSCharacter : BSPhysObject
 
     public override void LockAngularMotion(OMV.Vector3 axis) { return; }
 
-    public override OMV.Vector3 RawPosition
-    {
-        get { return _position; }
-        set { _position = value; }
-    }
     public override OMV.Vector3 Position {
         get {
             // Don't refetch the position because this function is called a zillion times
-            // _position = PhysicsScene.PE.GetObjectPosition(Scene.World, LocalID);
-            return _position;
+            // RawPosition = PhysicsScene.PE.GetObjectPosition(Scene.World, LocalID);
+            return RawPosition;
         }
         set {
-            _position = value;
+            RawPosition = value;
 
-            PhysicsScene.TaintedObject("BSCharacter.setPosition", delegate()
+            PhysScene.TaintedObject(LocalID, "BSCharacter.setPosition", delegate()
             {
-                DetailLog("{0},BSCharacter.SetPosition,taint,pos={1},orient={2}", LocalID, _position, _orientation);
+                DetailLog("{0},BSCharacter.SetPosition,taint,pos={1},orient={2}", LocalID, RawPosition, RawOrientation);
                 PositionSanityCheck();
-                ForcePosition = _position;
+                ForcePosition = RawPosition;
             });
         }
     }
     public override OMV.Vector3 ForcePosition {
         get {
-            _position = PhysicsScene.PE.GetPosition(PhysBody);
-            return _position;
+            RawPosition = PhysScene.PE.GetPosition(PhysBody);
+            return RawPosition;
         }
         set {
-            _position = value;
+            RawPosition = value;
             if (PhysBody.HasPhysicalBody)
             {
-                PhysicsScene.PE.SetTranslation(PhysBody, _position, _orientation);
+                PhysScene.PE.SetTranslation(PhysBody, RawPosition, RawOrientation);
             }
         }
     }
@@ -474,30 +322,30 @@ public sealed class BSCharacter : BSPhysObject
         bool ret = false;
 
         // TODO: check for out of bounds
-        if (!PhysicsScene.TerrainManager.IsWithinKnownTerrain(RawPosition))
+        if (!PhysScene.TerrainManager.IsWithinKnownTerrain(RawPosition))
         {
             // The character is out of the known/simulated area.
             // Force the avatar position to be within known. ScenePresence will use the position
             //    plus the velocity to decide if the avatar is moving out of the region.
-            RawPosition = PhysicsScene.TerrainManager.ClampPositionIntoKnownTerrain(RawPosition);
+            RawPosition = PhysScene.TerrainManager.ClampPositionIntoKnownTerrain(RawPosition);
             DetailLog("{0},BSCharacter.PositionSanityCheck,notWithinKnownTerrain,clampedPos={1}", LocalID, RawPosition);
             return true;
         }
 
         // If below the ground, move the avatar up
-        float terrainHeight = PhysicsScene.TerrainManager.GetTerrainHeightAtXYZ(RawPosition);
+        float terrainHeight = PhysScene.TerrainManager.GetTerrainHeightAtXYZ(RawPosition);
         if (Position.Z < terrainHeight)
         {
-            DetailLog("{0},BSCharacter.PositionSanityCheck,adjustForUnderGround,pos={1},terrain={2}", LocalID, _position, terrainHeight);
-            _position.Z = terrainHeight + BSParam.AvatarBelowGroundUpCorrectionMeters;
+            DetailLog("{0},BSCharacter.PositionSanityCheck,adjustForUnderGround,pos={1},terrain={2}", LocalID, RawPosition, terrainHeight);
+            RawPosition = new OMV.Vector3(RawPosition.X, RawPosition.Y, terrainHeight + BSParam.AvatarBelowGroundUpCorrectionMeters);
             ret = true;
         }
         if ((CurrentCollisionFlags & CollisionFlags.BS_FLOATS_ON_WATER) != 0)
         {
-            float waterHeight = PhysicsScene.TerrainManager.GetWaterLevelAtXYZ(_position);
+            float waterHeight = PhysScene.TerrainManager.GetWaterLevelAtXYZ(RawPosition);
             if (Position.Z < waterHeight)
             {
-                _position.Z = waterHeight;
+                RawPosition = new OMV.Vector3(RawPosition.X, RawPosition.Y, waterHeight);
                 ret = true;
             }
         }
@@ -515,10 +363,10 @@ public sealed class BSCharacter : BSPhysObject
         {
             // The new position value must be pushed into the physics engine but we can't
             //    just assign to "Position" because of potential call loops.
-            PhysicsScene.TaintedObject(inTaintTime, "BSCharacter.PositionSanityCheck", delegate()
+            PhysScene.TaintedObject(inTaintTime, LocalID, "BSCharacter.PositionSanityCheck", delegate()
             {
-                DetailLog("{0},BSCharacter.PositionSanityCheck,taint,pos={1},orient={2}", LocalID, _position, _orientation);
-                ForcePosition = _position;
+                DetailLog("{0},BSCharacter.PositionSanityCheck,taint,pos={1},orient={2}", LocalID, RawPosition, RawOrientation);
+                ForcePosition = RawPosition;
             });
             ret = true;
         }
@@ -528,25 +376,25 @@ public sealed class BSCharacter : BSPhysObject
     public override float Mass { get { return _mass; } }
 
     // used when we only want this prim's mass and not the linkset thing
-    public override float RawMass { 
+    public override float RawMass {
         get {return _mass; }
     }
     public override void UpdatePhysicalMassProperties(float physMass, bool inWorld)
     {
-        OMV.Vector3 localInertia = PhysicsScene.PE.CalculateLocalInertia(PhysShape, physMass);
-        PhysicsScene.PE.SetMassProps(PhysBody, physMass, localInertia);
+        OMV.Vector3 localInertia = PhysScene.PE.CalculateLocalInertia(PhysShape.physShapeInfo, physMass);
+        PhysScene.PE.SetMassProps(PhysBody, physMass, localInertia);
     }
 
     public override OMV.Vector3 Force {
-        get { return _force; }
+        get { return RawForce; }
         set {
-            _force = value;
+            RawForce = value;
             // m_log.DebugFormat("{0}: Force = {1}", LogHeader, _force);
-            PhysicsScene.TaintedObject("BSCharacter.SetForce", delegate()
+            PhysScene.TaintedObject(LocalID, "BSCharacter.SetForce", delegate()
             {
-                DetailLog("{0},BSCharacter.setForce,taint,force={1}", LocalID, _force);
+                DetailLog("{0},BSCharacter.setForce,taint,force={1}", LocalID, RawForce);
                 if (PhysBody.HasPhysicalBody)
-                    PhysicsScene.PE.SetObjectForce(PhysBody, _force);
+                    PhysScene.PE.SetObjectForce(PhysBody, RawForce);
             });
         }
     }
@@ -560,6 +408,7 @@ public sealed class BSCharacter : BSPhysObject
 
     // Allows the detection of collisions with inherently non-physical prims. see llVolumeDetect for more
     public override void SetVolumeDetect(int param) { return; }
+    public override bool IsVolumeDetect { get { return false; } }
 
     public override OMV.Vector3 GeometricCenter { get { return OMV.Vector3.Zero; } }
     public override OMV.Vector3 CenterOfMass { get { return OMV.Vector3.Zero; } }
@@ -569,61 +418,49 @@ public sealed class BSCharacter : BSPhysObject
     {
         get
         {
-            return m_targetVelocity;
+            return base.m_targetVelocity;
         }
         set
         {
             DetailLog("{0},BSCharacter.setTargetVelocity,call,vel={1}", LocalID, value);
             m_targetVelocity = value;
             OMV.Vector3 targetVel = value;
-            if (_setAlwaysRun)
+            if (_setAlwaysRun && !_flying)
                 targetVel *= new OMV.Vector3(BSParam.AvatarAlwaysRunFactor, BSParam.AvatarAlwaysRunFactor, 0f);
 
-            PhysicsScene.TaintedObject("BSCharacter.setTargetVelocity", delegate()
-            {
-                _velocityMotor.Reset();
-                _velocityMotor.SetTarget(targetVel);
-                _velocityMotor.SetCurrent(_velocity);
-                _velocityMotor.Enabled = true;
-            });
+            if (m_moveActor != null)
+                m_moveActor.SetVelocityAndTarget(RawVelocity, targetVel, false /* inTaintTime */);
         }
     }
-    public override OMV.Vector3 RawVelocity
-    {
-        get { return _velocity; }
-        set { _velocity = value; }
-    }
     // Directly setting velocity means this is what the user really wants now.
     public override OMV.Vector3 Velocity {
-        get { return _velocity; }
+        get { return RawVelocity; }
         set {
-            _velocity = value;
-            // m_log.DebugFormat("{0}: set velocity = {1}", LogHeader, _velocity);
-            PhysicsScene.TaintedObject("BSCharacter.setVelocity", delegate()
+            RawVelocity = value;
+            // m_log.DebugFormat("{0}: set velocity = {1}", LogHeader, RawVelocity);
+            PhysScene.TaintedObject(LocalID, "BSCharacter.setVelocity", delegate()
             {
-                _velocityMotor.Reset();
-                _velocityMotor.SetCurrent(_velocity);
-                _velocityMotor.SetTarget(_velocity);
-                _velocityMotor.Enabled = false;
+                if (m_moveActor != null)
+                    m_moveActor.SetVelocityAndTarget(RawVelocity, RawVelocity, true /* inTaintTime */);
 
-                DetailLog("{0},BSCharacter.setVelocity,taint,vel={1}", LocalID, _velocity);
-                ForceVelocity = _velocity;
+                DetailLog("{0},BSCharacter.setVelocity,taint,vel={1}", LocalID, RawVelocity);
+                ForceVelocity = RawVelocity;
             });
         }
     }
     public override OMV.Vector3 ForceVelocity {
-        get { return _velocity; }
+        get { return RawVelocity; }
         set {
-            PhysicsScene.AssertInTaintTime("BSCharacter.ForceVelocity");
+            PhysScene.AssertInTaintTime("BSCharacter.ForceVelocity");
 
-            _velocity = value;
-            PhysicsScene.PE.SetLinearVelocity(PhysBody, _velocity);
-            PhysicsScene.PE.Activate(PhysBody, true);
+            RawVelocity = value;
+            PhysScene.PE.SetLinearVelocity(PhysBody, RawVelocity);
+            PhysScene.PE.Activate(PhysBody, true);
         }
     }
     public override OMV.Vector3 Torque {
-        get { return _torque; }
-        set { _torque = value;
+        get { return RawTorque; }
+        set { RawTorque = value;
         }
     }
     public override float CollisionScore {
@@ -635,22 +472,27 @@ public sealed class BSCharacter : BSPhysObject
         get { return _acceleration; }
         set { _acceleration = value; }
     }
-    public override OMV.Quaternion RawOrientation
-    {
-        get { return _orientation; }
-        set { _orientation = value; }
-    }
     public override OMV.Quaternion Orientation {
-        get { return _orientation; }
+        get { return RawOrientation; }
         set {
             // Orientation is set zillions of times when an avatar is walking. It's like
             //      the viewer doesn't trust us.
-            if (_orientation != value)
+            if (RawOrientation != value)
             {
-                _orientation = value;
-                PhysicsScene.TaintedObject("BSCharacter.setOrientation", delegate()
+                RawOrientation = value;
+                PhysScene.TaintedObject(LocalID, "BSCharacter.setOrientation", delegate()
                 {
-                    ForceOrientation = _orientation;
+                    // Bullet assumes we know what we are doing when forcing orientation
+                    //    so it lets us go against all the rules and just compensates for them later.
+                    // This forces rotation to be only around the Z axis and doesn't change any of the other axis.
+                    // This keeps us from flipping the capsule over which the veiwer does not understand.
+                    float oRoll, oPitch, oYaw;
+                    RawOrientation.GetEulerAngles(out oRoll, out oPitch, out oYaw);
+                    OMV.Quaternion trimmedOrientation = OMV.Quaternion.CreateFromEulers(0f, 0f, oYaw);
+                    // DetailLog("{0},BSCharacter.setOrientation,taint,val={1},valDir={2},conv={3},convDir={4}",
+                    //                 LocalID, RawOrientation, OMV.Vector3.UnitX * RawOrientation,
+                    //                 trimmedOrientation, OMV.Vector3.UnitX * trimmedOrientation);
+                    ForceOrientation = trimmedOrientation;
                 });
             }
         }
@@ -660,16 +502,16 @@ public sealed class BSCharacter : BSPhysObject
     {
         get
         {
-            _orientation = PhysicsScene.PE.GetOrientation(PhysBody);
-            return _orientation;
+            RawOrientation = PhysScene.PE.GetOrientation(PhysBody);
+            return RawOrientation;
         }
         set
         {
-            _orientation = value;
+            RawOrientation = value;
             if (PhysBody.HasPhysicalBody)
             {
-                // _position = PhysicsScene.PE.GetPosition(BSBody);
-                PhysicsScene.PE.SetTranslation(PhysBody, _position, _orientation);
+                // RawPosition = PhysicsScene.PE.GetPosition(BSBody);
+                PhysScene.PE.SetTranslation(PhysBody, RawPosition, RawOrientation);
             }
         }
     }
@@ -718,14 +560,14 @@ public sealed class BSCharacter : BSPhysObject
     public override bool FloatOnWater {
         set {
             _floatOnWater = value;
-            PhysicsScene.TaintedObject("BSCharacter.setFloatOnWater", delegate()
+            PhysScene.TaintedObject(LocalID, "BSCharacter.setFloatOnWater", delegate()
             {
                 if (PhysBody.HasPhysicalBody)
                 {
                     if (_floatOnWater)
-                        CurrentCollisionFlags = PhysicsScene.PE.AddToCollisionFlags(PhysBody, CollisionFlags.BS_FLOATS_ON_WATER);
+                        CurrentCollisionFlags = PhysScene.PE.AddToCollisionFlags(PhysBody, CollisionFlags.BS_FLOATS_ON_WATER);
                     else
-                        CurrentCollisionFlags = PhysicsScene.PE.RemoveFromCollisionFlags(PhysBody, CollisionFlags.BS_FLOATS_ON_WATER);
+                        CurrentCollisionFlags = PhysScene.PE.RemoveFromCollisionFlags(PhysBody, CollisionFlags.BS_FLOATS_ON_WATER);
                 }
             });
         }
@@ -746,7 +588,7 @@ public sealed class BSCharacter : BSPhysObject
     public override float Buoyancy {
         get { return _buoyancy; }
         set { _buoyancy = value;
-            PhysicsScene.TaintedObject("BSCharacter.setBuoyancy", delegate()
+            PhysScene.TaintedObject(LocalID, "BSCharacter.setBuoyancy", delegate()
             {
                 DetailLog("{0},BSCharacter.setBuoyancy,taint,buoy={1}", LocalID, _buoyancy);
                 ForceBuoyancy = _buoyancy;
@@ -755,8 +597,8 @@ public sealed class BSCharacter : BSPhysObject
     }
     public override float ForceBuoyancy {
         get { return _buoyancy; }
-        set { 
-            PhysicsScene.AssertInTaintTime("BSCharacter.ForceBuoyancy");
+        set {
+            PhysScene.AssertInTaintTime("BSCharacter.ForceBuoyancy");
 
             _buoyancy = value;
             DetailLog("{0},BSCharacter.setForceBuoyancy,taint,buoy={1}", LocalID, _buoyancy);
@@ -764,7 +606,7 @@ public sealed class BSCharacter : BSPhysObject
             float  grav = BSParam.Gravity * (1f - _buoyancy);
             Gravity = new OMV.Vector3(0f, 0f, grav);
             if (PhysBody.HasPhysicalBody)
-                PhysicsScene.PE.SetGravity(PhysBody, Gravity);
+                PhysScene.PE.SetGravity(PhysBody, Gravity);
         }
     }
 
@@ -779,46 +621,25 @@ public sealed class BSCharacter : BSPhysObject
         set { _PIDTau = value; }
     }
 
-    // Used for llSetHoverHeight and maybe vehicle height
-    // Hover Height will override MoveTo target's Z
-    public override bool PIDHoverActive {
-        set { _useHoverPID = value; }
-    }
-    public override float PIDHoverHeight {
-        set { _PIDHoverHeight = value; }
-    }
-    public override PIDHoverType PIDHoverType {
-        set { _PIDHoverType = value; }
-    }
-    public override float PIDHoverTau {
-        set { _PIDHoverTao = value; }
-    }
-
-    // For RotLookAt
-    public override OMV.Quaternion APIDTarget { set { return; } }
-    public override bool APIDActive { set { return; } }
-    public override float APIDStrength { set { return; } }
-    public override float APIDDamping { set { return; } }
-
     public override void AddForce(OMV.Vector3 force, bool pushforce)
     {
         // Since this force is being applied in only one step, make this a force per second.
-        OMV.Vector3 addForce = force / PhysicsScene.LastTimeStep;
+        OMV.Vector3 addForce = force / PhysScene.LastTimeStep;
         AddForce(addForce, pushforce, false);
     }
-    private void AddForce(OMV.Vector3 force, bool pushforce, bool inTaintTime) {
+    public override void AddForce(OMV.Vector3 force, bool pushforce, bool inTaintTime) {
         if (force.IsFinite())
         {
             OMV.Vector3 addForce = Util.ClampV(force, BSParam.MaxAddForceMagnitude);
             // DetailLog("{0},BSCharacter.addForce,call,force={1}", LocalID, addForce);
 
-            PhysicsScene.TaintedObject(inTaintTime, "BSCharacter.AddForce", delegate()
+            PhysScene.TaintedObject(inTaintTime, LocalID, "BSCharacter.AddForce", delegate()
             {
                 // Bullet adds this central force to the total force for this tick
                 // DetailLog("{0},BSCharacter.addForce,taint,force={1}", LocalID, addForce);
                 if (PhysBody.HasPhysicalBody)
                 {
-                    PhysicsScene.PE.ApplyCentralForce(PhysBody, addForce);
+                    PhysScene.PE.ApplyCentralForce(PhysBody, addForce);
                 }
             });
         }
@@ -829,7 +650,7 @@ public sealed class BSCharacter : BSPhysObject
         }
     }
 
-    public override void AddAngularForce(OMV.Vector3 force, bool pushforce) {
+    public override void AddAngularForce(OMV.Vector3 force, bool pushforce, bool inTaintTime) {
     }
     public override void SetMomentum(OMV.Vector3 momentum) {
     }
@@ -837,14 +658,14 @@ public sealed class BSCharacter : BSPhysObject
     private OMV.Vector3 ComputeAvatarScale(OMV.Vector3 size)
     {
         OMV.Vector3 newScale;
-        
+
         // Bullet's capsule total height is the "passed height + radius * 2";
-        // The base capsule is 1 diameter and 2 height (passed radius=0.5, passed height = 1)
+        // The base capsule is 1 unit in diameter and 2 units in height (passed radius=0.5, passed height = 1)
         // The number we pass in for 'scaling' is the multiplier to get that base
         //     shape to be the size desired.
         // So, when creating the scale for the avatar height, we take the passed height
         //     (size.Z) and remove the caps.
-        // Another oddity of the Bullet capsule implementation is that it presumes the Y
+        // An oddity of the Bullet capsule implementation is that it presumes the Y
         //     dimension is the radius of the capsule. Even though some of the code allows
         //     for a asymmetrical capsule, other parts of the code presume it is cylindrical.
 
@@ -852,12 +673,36 @@ public sealed class BSCharacter : BSPhysObject
         newScale.X = size.X / 2f;
         newScale.Y = size.Y / 2f;
 
+        float heightAdjust = BSParam.AvatarHeightMidFudge;
+        if (BSParam.AvatarHeightLowFudge != 0f || BSParam.AvatarHeightHighFudge != 0f)
+        {
+            const float AVATAR_LOW = 1.1f;
+            const float AVATAR_MID = 1.775f; // 1.87f
+            const float AVATAR_HI = 2.45f;
+            // An avatar is between 1.1 and 2.45 meters. Midpoint is 1.775m.
+            float midHeightOffset = size.Z - AVATAR_MID;
+            if (midHeightOffset < 0f)
+            {
+                // Small avatar. Add the adjustment based on the distance from midheight
+                heightAdjust += ((-1f * midHeightOffset) / (AVATAR_MID - AVATAR_LOW)) * BSParam.AvatarHeightLowFudge;
+            }
+            else
+            {
+                // Large avatar. Add the adjustment based on the distance from midheight
+                heightAdjust += ((midHeightOffset) / (AVATAR_HI - AVATAR_MID)) * BSParam.AvatarHeightHighFudge;
+            }
+        }
         // The total scale height is the central cylindar plus the caps on the two ends.
-        newScale.Z = (size.Z + (Math.Min(size.X, size.Y) * 2)) / 2f;
+        newScale.Z = (size.Z + (Math.Min(size.X, size.Y) * 2) + heightAdjust) / 2f;
+        // m_log.DebugFormat("{0} ComputeAvatarScale: size={1},adj={2},scale={3}", LogHeader, size, heightAdjust, newScale);
+
         // If smaller than the endcaps, just fake like we're almost that small
         if (newScale.Z < 0)
             newScale.Z = 0.1f;
 
+        DetailLog("{0},BSCharacter.ComputerAvatarScale,size={1},lowF={2},midF={3},hiF={4},adj={5},newScale={6}",
+            LocalID, size, BSParam.AvatarHeightLowFudge, BSParam.AvatarHeightMidFudge, BSParam.AvatarHeightHighFudge, heightAdjust, newScale);
+
         return newScale;
     }
 
@@ -882,15 +727,18 @@ public sealed class BSCharacter : BSPhysObject
     // the world that things have changed.
     public override void UpdateProperties(EntityProperties entprop)
     {
-        _position = entprop.Position;
-        _orientation = entprop.Rotation;
+        // Let anyone (like the actors) modify the updated properties before they are pushed into the object and the simulator.
+        TriggerPreUpdatePropertyAction(ref entprop);
+
+        RawPosition = entprop.Position;
+        RawOrientation = entprop.Rotation;
 
         // Smooth velocity. OpenSimulator is VERY sensitive to changes in velocity of the avatar
         //    and will send agent updates to the clients if velocity changes by more than
         //    0.001m/s. Bullet introduces a lot of jitter in the velocity which causes many
         //    extra updates.
-        if (!entprop.Velocity.ApproxEquals(_velocity, 0.1f))
-            _velocity = entprop.Velocity;
+        if (!entprop.Velocity.ApproxEquals(RawVelocity, 0.1f))
+            RawVelocity = entprop.Velocity;
 
         _acceleration = entprop.Acceleration;
         _rotationalVelocity = entprop.RotationalVelocity;
@@ -898,8 +746,8 @@ public sealed class BSCharacter : BSPhysObject
         // Do some sanity checking for the avatar. Make sure it's above ground and inbounds.
         if (PositionSanityCheck(true))
         {
-            DetailLog("{0},BSCharacter.UpdateProperties,updatePosForSanity,pos={1}", LocalID, _position);
-            entprop.Position = _position;
+            DetailLog("{0},BSCharacter.UpdateProperties,updatePosForSanity,pos={1}", LocalID, RawPosition);
+            entprop.Position = RawPosition;
         }
 
         // remember the current and last set values
@@ -910,10 +758,10 @@ public sealed class BSCharacter : BSPhysObject
         // Linkset.UpdateProperties(UpdatedProperties.EntPropUpdates, this);
 
         // Avatars don't report their changes the usual way. Changes are checked for in the heartbeat loop.
-        // base.RequestPhysicsterseUpdate();
+        // PhysScene.PostUpdate(this);
 
         DetailLog("{0},BSCharacter.UpdateProperties,call,pos={1},orient={2},vel={3},accel={4},rotVel={5}",
-                LocalID, _position, _orientation, _velocity, _acceleration, _rotationalVelocity);
+                LocalID, RawPosition, RawOrientation, RawVelocity, _acceleration, _rotationalVelocity);
     }
 }
 }
diff --git a/OpenSim/Region/Physics/BulletSPlugin/BSConstraint.cs b/OpenSim/Region/Physics/BulletSPlugin/BSConstraint.cs
index b813974..b47e9a8 100755
--- a/OpenSim/Region/Physics/BulletSPlugin/BSConstraint.cs
+++ b/OpenSim/Region/Physics/BulletSPlugin/BSConstraint.cs
@@ -64,7 +64,7 @@ public abstract class BSConstraint : IDisposable
             {
                 bool success = PhysicsScene.PE.DestroyConstraint(m_world, m_constraint);
                 m_world.physicsScene.DetailLog("{0},BSConstraint.Dispose,taint,id1={1},body1={2},id2={3},body2={4},success={5}",
-                                    BSScene.DetailLogZero,
+                                    m_body1.ID,
                                     m_body1.ID, m_body1.AddrString,
                                     m_body2.ID, m_body2.AddrString,
                                     success);
@@ -77,7 +77,10 @@ public abstract class BSConstraint : IDisposable
     {
         bool ret = false;
         if (m_enabled)
+        {
+            m_world.physicsScene.DetailLog("{0},BSConstraint.SetLinearLimits,taint,low={1},high={2}", m_body1.ID, low, high);
             ret = PhysicsScene.PE.SetLinearLimits(m_constraint, low, high);
+        }
         return ret;
     }
 
@@ -85,7 +88,10 @@ public abstract class BSConstraint : IDisposable
     {
         bool ret = false;
         if (m_enabled)
+        {
+            m_world.physicsScene.DetailLog("{0},BSConstraint.SetAngularLimits,taint,low={1},high={2}", m_body1.ID, low, high);
             ret = PhysicsScene.PE.SetAngularLimits(m_constraint, low, high);
+        }
         return ret;
     }
 
diff --git a/OpenSim/Region/Physics/BulletSPlugin/BSConstraint6Dof.cs b/OpenSim/Region/Physics/BulletSPlugin/BSConstraint6Dof.cs
index 476a0e5..7fcb75c 100755
--- a/OpenSim/Region/Physics/BulletSPlugin/BSConstraint6Dof.cs
+++ b/OpenSim/Region/Physics/BulletSPlugin/BSConstraint6Dof.cs
@@ -32,12 +32,19 @@ using OpenMetaverse;
 namespace OpenSim.Region.Physics.BulletSPlugin
 {
 
-public sealed class BSConstraint6Dof : BSConstraint
+public class BSConstraint6Dof : BSConstraint
 {
     private static string LogHeader = "[BULLETSIM 6DOF CONSTRAINT]";
 
     public override ConstraintType Type { get { return ConstraintType.D6_CONSTRAINT_TYPE; } }
 
+    public BSConstraint6Dof(BulletWorld world, BulletBody obj1, BulletBody obj2) :base(world)
+    {
+        m_body1 = obj1;
+        m_body2 = obj2;
+        m_enabled = false;
+    }
+
     // Create a btGeneric6DofConstraint
     public BSConstraint6Dof(BulletWorld world, BulletBody obj1, BulletBody obj2,
                     Vector3 frame1, Quaternion frame1rot,
@@ -52,9 +59,11 @@ public sealed class BSConstraint6Dof : BSConstraint
                                 frame2, frame2rot,
                                 useLinearReferenceFrameA, disableCollisionsBetweenLinkedBodies);
         m_enabled = true;
-        world.physicsScene.DetailLog("{0},BS6DofConstraint,createFrame,wID={1}, rID={2}, rBody={3}, cID={4}, cBody={5}",
-                            BSScene.DetailLogZero, world.worldID,
+        PhysicsScene.DetailLog("{0},BS6DofConstraint,create,wID={1}, rID={2}, rBody={3}, cID={4}, cBody={5}",
+                            m_body1.ID, world.worldID,
                             obj1.ID, obj1.AddrString, obj2.ID, obj2.AddrString);
+        PhysicsScene.DetailLog("{0},BS6DofConstraint,create,  f1Loc={1},f1Rot={2},f2Loc={3},f2Rot={4},usefA={5},disCol={6}",
+                            m_body1.ID, frame1, frame1rot, frame2, frame2rot, useLinearReferenceFrameA, disableCollisionsBetweenLinkedBodies);
     }
 
     // 6 Dof constraint based on a midpoint between the two constrained bodies
@@ -79,9 +88,11 @@ public sealed class BSConstraint6Dof : BSConstraint
             m_constraint = PhysicsScene.PE.Create6DofConstraintToPoint(m_world, m_body1, m_body2,
                                     joinPoint,
                                     useLinearReferenceFrameA, disableCollisionsBetweenLinkedBodies);
+
             PhysicsScene.DetailLog("{0},BS6DofConstraint,createMidPoint,wID={1}, csrt={2}, rID={3}, rBody={4}, cID={5}, cBody={6}",
-                                BSScene.DetailLogZero, world.worldID, m_constraint.AddrString,
+                                m_body1.ID, world.worldID, m_constraint.AddrString,
                                 obj1.ID, obj1.AddrString, obj2.ID, obj2.AddrString);
+
             if (!m_constraint.HasPhysicalConstraint)
             {
                 world.physicsScene.Logger.ErrorFormat("{0} Failed creation of 6Dof constraint. rootID={1}, childID={2}",
@@ -97,17 +108,19 @@ public sealed class BSConstraint6Dof : BSConstraint
 
     // A 6 Dof constraint that is fixed in the world and constrained to a on-the-fly created static object
     public BSConstraint6Dof(BulletWorld world, BulletBody obj1, Vector3 frameInBloc, Quaternion frameInBrot,
-                    bool useLinearReferenceFrameA, bool disableCollisionsBetweenLinkedBodies)
+                    bool useLinearReferenceFrameB, bool disableCollisionsBetweenLinkedBodies)
         : base(world)
     {
         m_body1 = obj1;
         m_body2 = obj1; // Look out for confusion down the road
         m_constraint = PhysicsScene.PE.Create6DofConstraintFixed(m_world, m_body1,
                                 frameInBloc, frameInBrot,
-                                useLinearReferenceFrameA, disableCollisionsBetweenLinkedBodies);
+                                useLinearReferenceFrameB, disableCollisionsBetweenLinkedBodies);
         m_enabled = true;
-        world.physicsScene.DetailLog("{0},BS6DofConstraint,createFixed,wID={1},rID={2},rBody={3}",
-                            BSScene.DetailLogZero, world.worldID, obj1.ID, obj1.AddrString);
+        PhysicsScene.DetailLog("{0},BS6DofConstraint,createFixed,wID={1},rID={2},rBody={3}",
+                                    m_body1.ID, world.worldID, obj1.ID, obj1.AddrString);
+        PhysicsScene.DetailLog("{0},BS6DofConstraint,createFixed,  fBLoc={1},fBRot={2},usefA={3},disCol={4}",
+                            m_body1.ID, frameInBloc, frameInBrot, useLinearReferenceFrameB, disableCollisionsBetweenLinkedBodies);
     }
 
     public bool SetFrames(Vector3 frameA, Quaternion frameArot, Vector3 frameB, Quaternion frameBrot)
diff --git a/OpenSim/Region/Physics/BulletSPlugin/BSConstraintConeTwist.cs b/OpenSim/Region/Physics/BulletSPlugin/BSConstraintConeTwist.cs
new file mode 100755
index 0000000..7a76a9a
--- /dev/null
+++ b/OpenSim/Region/Physics/BulletSPlugin/BSConstraintConeTwist.cs
@@ -0,0 +1,54 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyrightD
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSimulator Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+using System;
+using System.Collections.Generic;
+using System.Text;
+using OpenMetaverse;
+
+namespace OpenSim.Region.Physics.BulletSPlugin
+{
+
+public sealed class BSConstraintConeTwist : BSConstraint
+{
+    public override ConstraintType Type { get { return ConstraintType.CONETWIST_CONSTRAINT_TYPE; } }
+
+    public BSConstraintConeTwist(BulletWorld world, BulletBody obj1, BulletBody obj2,
+                    Vector3 frameInAloc, Quaternion frameInArot,
+                    Vector3 frameInBloc, Quaternion frameInBrot,
+                    bool disableCollisionsBetweenLinkedBodies)
+        : base(world)
+    {
+        m_body1 = obj1;
+        m_body2 = obj2;
+        m_constraint = PhysicsScene.PE.CreateConeTwistConstraint(world, obj1, obj2,
+                                frameInAloc, frameInArot, frameInBloc, frameInBrot,
+                                disableCollisionsBetweenLinkedBodies);
+        m_enabled = true;
+    }
+}
+
+}
diff --git a/OpenSim/Region/Physics/BulletSPlugin/BSConstraintHinge.cs b/OpenSim/Region/Physics/BulletSPlugin/BSConstraintHinge.cs
index 7714a03..ed89f63 100755
--- a/OpenSim/Region/Physics/BulletSPlugin/BSConstraintHinge.cs
+++ b/OpenSim/Region/Physics/BulletSPlugin/BSConstraintHinge.cs
@@ -45,7 +45,7 @@ public sealed class BSConstraintHinge : BSConstraint
         m_body1 = obj1;
         m_body2 = obj2;
         m_constraint = PhysicsScene.PE.CreateHingeConstraint(world, obj1, obj2,
-                                pivotInA, pivotInB, axisInA, axisInB, 
+                                pivotInA, pivotInB, axisInA, axisInB,
                                 useLinearReferenceFrameA, disableCollisionsBetweenLinkedBodies);
         m_enabled = true;
     }
diff --git a/OpenSim/Region/Physics/BulletSPlugin/BSConstraintSlider.cs b/OpenSim/Region/Physics/BulletSPlugin/BSConstraintSlider.cs
new file mode 100755
index 0000000..37cfa07
--- /dev/null
+++ b/OpenSim/Region/Physics/BulletSPlugin/BSConstraintSlider.cs
@@ -0,0 +1,55 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyrightD
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSimulator Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+using System;
+using System.Collections.Generic;
+using System.Text;
+using OpenMetaverse;
+
+namespace OpenSim.Region.Physics.BulletSPlugin
+{
+
+public sealed class BSConstraintSlider : BSConstraint
+{
+    public override ConstraintType Type { get { return ConstraintType.SLIDER_CONSTRAINT_TYPE; } }
+
+    public BSConstraintSlider(BulletWorld world, BulletBody obj1, BulletBody obj2,
+                    Vector3 frameInAloc, Quaternion frameInArot,
+                    Vector3 frameInBloc, Quaternion frameInBrot,
+                    bool useLinearReferenceFrameA, bool disableCollisionsBetweenLinkedBodies)
+        : base(world)
+    {
+        m_body1 = obj1;
+        m_body2 = obj2;
+        m_constraint = PhysicsScene.PE.CreateSliderConstraint(world, obj1, obj2,
+                                frameInAloc, frameInArot, frameInBloc, frameInBrot,
+                                useLinearReferenceFrameA, disableCollisionsBetweenLinkedBodies);
+        m_enabled = true;
+    }
+
+}
+
+}
diff --git a/OpenSim/Region/Physics/BulletSPlugin/BSConstraintSpring.cs b/OpenSim/Region/Physics/BulletSPlugin/BSConstraintSpring.cs
new file mode 100755
index 0000000..8e7ddff
--- /dev/null
+++ b/OpenSim/Region/Physics/BulletSPlugin/BSConstraintSpring.cs
@@ -0,0 +1,103 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyrightD
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSimulator Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+using System;
+using System.Collections.Generic;
+using System.Text;
+using OpenMetaverse;
+
+namespace OpenSim.Region.Physics.BulletSPlugin
+{
+
+public sealed class BSConstraintSpring : BSConstraint6Dof
+{
+    public override ConstraintType Type { get { return ConstraintType.D6_SPRING_CONSTRAINT_TYPE; } }
+
+    public BSConstraintSpring(BulletWorld world, BulletBody obj1, BulletBody obj2,
+                    Vector3 frame1Loc, Quaternion frame1Rot,
+                    Vector3 frame2Loc, Quaternion frame2Rot,
+                    bool useLinearReferenceFrameA, bool disableCollisionsBetweenLinkedBodies)
+        :base(world, obj1, obj2)
+    {
+        m_constraint = PhysicsScene.PE.Create6DofSpringConstraint(world, obj1, obj2,
+                                frame1Loc, frame1Rot, frame2Loc, frame2Rot,
+                                useLinearReferenceFrameA, disableCollisionsBetweenLinkedBodies);
+        m_enabled = true;
+
+        PhysicsScene.DetailLog("{0},BSConstraintSpring,create,wID={1}, rID={2}, rBody={3}, cID={4}, cBody={5}",
+                            obj1.ID, world.worldID, obj1.ID, obj1.AddrString, obj2.ID, obj2.AddrString);
+        PhysicsScene.DetailLog("{0},BSConstraintSpring,create,  f1Loc={1},f1Rot={2},f2Loc={3},f2Rot={4},usefA={5},disCol={6}",
+                    m_body1.ID, frame1Loc, frame1Rot, frame2Loc, frame2Rot, useLinearReferenceFrameA, disableCollisionsBetweenLinkedBodies);
+    }
+
+    public bool SetAxisEnable(int pIndex, bool pAxisEnable)
+    {
+        PhysicsScene.DetailLog("{0},BSConstraintSpring.SetEnable,obj1ID={1},obj2ID={2},indx={3},enable={4}",
+                                        m_body1.ID, m_body1.ID, m_body2.ID, pIndex, pAxisEnable);
+        PhysicsScene.PE.SpringEnable(m_constraint, pIndex, BSParam.NumericBool(pAxisEnable));
+        return true;
+    }
+
+    public bool SetStiffness(int pIndex, float pStiffness)
+    {
+        PhysicsScene.DetailLog("{0},BSConstraintSpring.SetStiffness,obj1ID={1},obj2ID={2},indx={3},stiff={4}",
+                                        m_body1.ID, m_body1.ID, m_body2.ID, pIndex, pStiffness);
+        PhysicsScene.PE.SpringSetStiffness(m_constraint, pIndex, pStiffness);
+        return true;
+    }
+
+    public bool SetDamping(int pIndex, float pDamping)
+    {
+        PhysicsScene.DetailLog("{0},BSConstraintSpring.SetDamping,obj1ID={1},obj2ID={2},indx={3},damp={4}",
+                                        m_body1.ID, m_body1.ID, m_body2.ID, pIndex, pDamping);
+        PhysicsScene.PE.SpringSetDamping(m_constraint, pIndex, pDamping);
+        return true;
+    }
+
+    public bool SetEquilibriumPoint(int pIndex, float pEqPoint)
+    {
+        PhysicsScene.DetailLog("{0},BSConstraintSpring.SetEquilibriumPoint,obj1ID={1},obj2ID={2},indx={3},eqPoint={4}",
+                                        m_body1.ID, m_body1.ID, m_body2.ID, pIndex, pEqPoint);
+        PhysicsScene.PE.SpringSetEquilibriumPoint(m_constraint, pIndex, pEqPoint);
+        return true;
+    }
+
+    public bool SetEquilibriumPoint(Vector3 linearEq, Vector3 angularEq)
+    {
+        PhysicsScene.DetailLog("{0},BSConstraintSpring.SetEquilibriumPoint,obj1ID={1},obj2ID={2},linearEq={3},angularEq={4}",
+                                        m_body1.ID, m_body1.ID, m_body2.ID, linearEq, angularEq);
+        PhysicsScene.PE.SpringSetEquilibriumPoint(m_constraint, 0, linearEq.X);
+        PhysicsScene.PE.SpringSetEquilibriumPoint(m_constraint, 1, linearEq.Y);
+        PhysicsScene.PE.SpringSetEquilibriumPoint(m_constraint, 2, linearEq.Z);
+        PhysicsScene.PE.SpringSetEquilibriumPoint(m_constraint, 3, angularEq.X);
+        PhysicsScene.PE.SpringSetEquilibriumPoint(m_constraint, 4, angularEq.Y);
+        PhysicsScene.PE.SpringSetEquilibriumPoint(m_constraint, 5, angularEq.Z);
+        return true;
+    }
+
+}
+
+}
\ No newline at end of file
diff --git a/OpenSim/Region/Physics/BulletSPlugin/BSDynamics.cs b/OpenSim/Region/Physics/BulletSPlugin/BSDynamics.cs
index 65df741..7b98f9d 100644
--- a/OpenSim/Region/Physics/BulletSPlugin/BSDynamics.cs
+++ b/OpenSim/Region/Physics/BulletSPlugin/BSDynamics.cs
@@ -40,13 +40,14 @@ using OpenSim.Region.Physics.Manager;
 
 namespace OpenSim.Region.Physics.BulletSPlugin
 {
-    public sealed class BSDynamics
+    public sealed class BSDynamics : BSActor
     {
         private static string LogHeader = "[BULLETSIM VEHICLE]";
 
-        private BSScene PhysicsScene { get; set; }
         // the prim this dynamic controller belongs to
-        private BSPrim Prim { get; set; }
+        private BSPrimLinkable ControllingPrim { get; set; }
+
+        private bool m_haveRegisteredForSceneEvents;
 
         // mass of the vehicle fetched each time we're calles
         private float m_vehicleMass;
@@ -124,38 +125,24 @@ namespace OpenSim.Region.Physics.BulletSPlugin
         static readonly float PIOverFour = ((float)Math.PI) / 4f;
         static readonly float PIOverTwo = ((float)Math.PI) / 2f;
 
-        // For debugging, flags to turn on and off individual corrections.
-        public bool enableAngularVerticalAttraction;
-        public bool enableAngularDeflection;
-        public bool enableAngularBanking;
-
-        public BSDynamics(BSScene myScene, BSPrim myPrim)
+        public BSDynamics(BSScene myScene, BSPrim myPrim, string actorName)
+            : base(myScene, myPrim, actorName)
         {
-            PhysicsScene = myScene;
-            Prim = myPrim;
             Type = Vehicle.TYPE_NONE;
-            SetupVehicleDebugging();
-        }
+            m_haveRegisteredForSceneEvents = false;
 
-        // Stopgap debugging enablement. Allows source level debugging but still checking
-        //    in changes by making enablement of debugging flags from INI file.
-        public void SetupVehicleDebugging()
-        {
-            enableAngularVerticalAttraction = true;
-            enableAngularDeflection = false;
-            enableAngularBanking = true;
-            if (BSParam.VehicleDebuggingEnabled)
+            ControllingPrim = myPrim as BSPrimLinkable;
+            if (ControllingPrim == null)
             {
-                enableAngularVerticalAttraction = true;
-                enableAngularDeflection = false;
-                enableAngularBanking = false;
+                // THIS CANNOT HAPPEN!!
             }
+            VDetailLog("{0},Creation", ControllingPrim.LocalID);
         }
 
         // Return 'true' if this vehicle is doing vehicle things
         public bool IsActive
         {
-            get { return (Type != Vehicle.TYPE_NONE && Prim.IsPhysicallyActive); }
+            get { return (Type != Vehicle.TYPE_NONE && ControllingPrim.IsPhysicallyActive); }
         }
 
         // Return 'true' if this a vehicle that should be sitting on the ground
@@ -167,11 +154,11 @@ namespace OpenSim.Region.Physics.BulletSPlugin
         #region Vehicle parameter setting
         public void ProcessFloatVehicleParam(Vehicle pParam, float pValue)
         {
-            VDetailLog("{0},ProcessFloatVehicleParam,param={1},val={2}", Prim.LocalID, pParam, pValue);
+            VDetailLog("{0},ProcessFloatVehicleParam,param={1},val={2}", ControllingPrim.LocalID, pParam, pValue);
             switch (pParam)
             {
                 case Vehicle.ANGULAR_DEFLECTION_EFFICIENCY:
-                    m_angularDeflectionEfficiency = Math.Max(pValue, 0.01f);
+                    m_angularDeflectionEfficiency = ClampInRange(0f, pValue, 1f);
                     break;
                 case Vehicle.ANGULAR_DEFLECTION_TIMESCALE:
                     m_angularDeflectionTimescale = Math.Max(pValue, 0.01f);
@@ -195,7 +182,7 @@ namespace OpenSim.Region.Physics.BulletSPlugin
                     break;
                 case Vehicle.BUOYANCY:
                     m_VehicleBuoyancy = ClampInRange(-1f, pValue, 1f);
-                    m_VehicleGravity = Prim.ComputeGravity(m_VehicleBuoyancy);
+                    m_VehicleGravity = ControllingPrim.ComputeGravity(m_VehicleBuoyancy);
                     break;
                 case Vehicle.HOVER_EFFICIENCY:
                     m_VhoverEfficiency = ClampInRange(0f, pValue, 1f);
@@ -207,7 +194,7 @@ namespace OpenSim.Region.Physics.BulletSPlugin
                     m_VhoverTimescale = Math.Max(pValue, 0.01f);
                     break;
                 case Vehicle.LINEAR_DEFLECTION_EFFICIENCY:
-                    m_linearDeflectionEfficiency = Math.Max(pValue, 0.01f);
+                    m_linearDeflectionEfficiency = ClampInRange(0f, pValue, 1f);
                     break;
                 case Vehicle.LINEAR_DEFLECTION_TIMESCALE:
                     m_linearDeflectionTimescale = Math.Max(pValue, 0.01f);
@@ -233,7 +220,6 @@ namespace OpenSim.Region.Physics.BulletSPlugin
                 // set all of the components to the same value
                 case Vehicle.ANGULAR_FRICTION_TIMESCALE:
                     m_angularFrictionTimescale = new Vector3(pValue, pValue, pValue);
-                    m_angularMotor.FrictionTimescale = m_angularFrictionTimescale;
                     break;
                 case Vehicle.ANGULAR_MOTOR_DIRECTION:
                     m_angularMotorDirection = new Vector3(pValue, pValue, pValue);
@@ -242,7 +228,6 @@ namespace OpenSim.Region.Physics.BulletSPlugin
                     break;
                 case Vehicle.LINEAR_FRICTION_TIMESCALE:
                     m_linearFrictionTimescale = new Vector3(pValue, pValue, pValue);
-                    m_linearMotor.FrictionTimescale = m_linearFrictionTimescale;
                     break;
                 case Vehicle.LINEAR_MOTOR_DIRECTION:
                     m_linearMotorDirection = new Vector3(pValue, pValue, pValue);
@@ -258,12 +243,11 @@ namespace OpenSim.Region.Physics.BulletSPlugin
 
         internal void ProcessVectorVehicleParam(Vehicle pParam, Vector3 pValue)
         {
-            VDetailLog("{0},ProcessVectorVehicleParam,param={1},val={2}", Prim.LocalID, pParam, pValue);
+            VDetailLog("{0},ProcessVectorVehicleParam,param={1},val={2}", ControllingPrim.LocalID, pParam, pValue);
             switch (pParam)
             {
                 case Vehicle.ANGULAR_FRICTION_TIMESCALE:
                     m_angularFrictionTimescale = new Vector3(pValue.X, pValue.Y, pValue.Z);
-                    m_angularMotor.FrictionTimescale = m_angularFrictionTimescale;
                     break;
                 case Vehicle.ANGULAR_MOTOR_DIRECTION:
                     // Limit requested angular speed to 2 rps= 4 pi rads/sec
@@ -276,7 +260,6 @@ namespace OpenSim.Region.Physics.BulletSPlugin
                     break;
                 case Vehicle.LINEAR_FRICTION_TIMESCALE:
                     m_linearFrictionTimescale = new Vector3(pValue.X, pValue.Y, pValue.Z);
-                    m_linearMotor.FrictionTimescale = m_linearFrictionTimescale;
                     break;
                 case Vehicle.LINEAR_MOTOR_DIRECTION:
                     m_linearMotorDirection = new Vector3(pValue.X, pValue.Y, pValue.Z);
@@ -294,7 +277,7 @@ namespace OpenSim.Region.Physics.BulletSPlugin
 
         internal void ProcessRotationVehicleParam(Vehicle pParam, Quaternion pValue)
         {
-            VDetailLog("{0},ProcessRotationalVehicleParam,param={1},val={2}", Prim.LocalID, pParam, pValue);
+            VDetailLog("{0},ProcessRotationalVehicleParam,param={1},val={2}", ControllingPrim.LocalID, pParam, pValue);
             switch (pParam)
             {
                 case Vehicle.REFERENCE_FRAME:
@@ -308,7 +291,7 @@ namespace OpenSim.Region.Physics.BulletSPlugin
 
         internal void ProcessVehicleFlags(int pParam, bool remove)
         {
-            VDetailLog("{0},ProcessVehicleFlags,param={1},remove={2}", Prim.LocalID, pParam, remove);
+            VDetailLog("{0},ProcessVehicleFlags,param={1},remove={2}", ControllingPrim.LocalID, pParam, remove);
             VehicleFlag parm = (VehicleFlag)pParam;
             if (pParam == -1)
                 m_flags = (VehicleFlag)0;
@@ -323,7 +306,7 @@ namespace OpenSim.Region.Physics.BulletSPlugin
 
         public void ProcessTypeChange(Vehicle pType)
         {
-            VDetailLog("{0},ProcessTypeChange,type={1}", Prim.LocalID, pType);
+            VDetailLog("{0},ProcessTypeChange,type={1}", ControllingPrim.LocalID, pType);
             // Set Defaults For Type
             Type = pType;
             switch (pType)
@@ -557,34 +540,40 @@ namespace OpenSim.Region.Physics.BulletSPlugin
                     break;
             }
 
-            // Update any physical parameters based on this type.
-            Refresh();
-
-            m_linearMotor = new BSVMotor("LinearMotor", m_linearMotorTimescale,
-                                m_linearMotorDecayTimescale, m_linearFrictionTimescale,
-                                1f);
-            m_linearMotor.PhysicsScene = PhysicsScene;  // DEBUG DEBUG DEBUG (enables detail logging)
+            m_linearMotor = new BSVMotor("LinearMotor", m_linearMotorTimescale, m_linearMotorDecayTimescale, 1f);
+            // m_linearMotor.PhysicsScene = m_physicsScene;  // DEBUG DEBUG DEBUG (enables detail logging)
 
-            m_angularMotor = new BSVMotor("AngularMotor", m_angularMotorTimescale,
-                                m_angularMotorDecayTimescale, m_angularFrictionTimescale,
-                                1f);
-            m_angularMotor.PhysicsScene = PhysicsScene;  // DEBUG DEBUG DEBUG (enables detail logging)
+            m_angularMotor = new BSVMotor("AngularMotor", m_angularMotorTimescale, m_angularMotorDecayTimescale, 1f);
+            // m_angularMotor.PhysicsScene = m_physicsScene;  // DEBUG DEBUG DEBUG (enables detail logging)
 
             /*  Not implemented
             m_verticalAttractionMotor = new BSVMotor("VerticalAttraction", m_verticalAttractionTimescale,
                                 BSMotor.Infinite, BSMotor.InfiniteVector,
                                 m_verticalAttractionEfficiency);
             // Z goes away and we keep X and Y
-            m_verticalAttractionMotor.FrictionTimescale = new Vector3(BSMotor.Infinite, BSMotor.Infinite, 0.1f);
             m_verticalAttractionMotor.PhysicsScene = PhysicsScene;  // DEBUG DEBUG DEBUG (enables detail logging)
              */
+
+            if (this.Type == Vehicle.TYPE_NONE)
+            {
+                UnregisterForSceneEvents();
+            }
+            else
+            {
+                RegisterForSceneEvents();
+            }
+
+            // Update any physical parameters based on this type.
+            Refresh();
         }
         #endregion // Vehicle parameter setting
 
-        public void Refresh()
+        // BSActor.Refresh()
+        public override void Refresh()
         {
             // If asking for a refresh, reset the physical parameters before the next simulation step.
-            PhysicsScene.PostTaintObject("BSDynamics.Refresh", Prim.LocalID, delegate()
+            // Called whether active or not since the active state may be updated before the next step.
+            m_physicsScene.PostTaintObject("BSDynamics.Refresh", ControllingPrim.LocalID, delegate()
             {
                 SetPhysicalParameters();
             });
@@ -597,49 +586,98 @@ namespace OpenSim.Region.Physics.BulletSPlugin
             if (IsActive)
             {
                 // Remember the mass so we don't have to fetch it every step
-                m_vehicleMass = Prim.TotalMass;
+                m_vehicleMass = ControllingPrim.TotalMass;
 
                 // Friction affects are handled by this vehicle code
-                PhysicsScene.PE.SetFriction(Prim.PhysBody, BSParam.VehicleFriction);
-                PhysicsScene.PE.SetRestitution(Prim.PhysBody, BSParam.VehicleRestitution);
+                // 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.
                 //     Maybe compute linear and angular factor and damping from params.
-                PhysicsScene.PE.SetAngularDamping(Prim.PhysBody, BSParam.VehicleAngularDamping);
-                PhysicsScene.PE.SetLinearFactor(Prim.PhysBody, BSParam.VehicleLinearFactor);
-                PhysicsScene.PE.SetAngularFactorV(Prim.PhysBody, BSParam.VehicleAngularFactor);
+                m_physicsScene.PE.SetAngularDamping(ControllingPrim.PhysBody, BSParam.VehicleAngularDamping);
+                m_physicsScene.PE.SetLinearFactor(ControllingPrim.PhysBody, BSParam.VehicleLinearFactor);
+                m_physicsScene.PE.SetAngularFactorV(ControllingPrim.PhysBody, BSParam.VehicleAngularFactor);
 
                 // Vehicles report collision events so we know when it's on the ground
-                PhysicsScene.PE.AddToCollisionFlags(Prim.PhysBody, CollisionFlags.BS_VEHICLE_COLLISIONS);
+                // m_physicsScene.PE.AddToCollisionFlags(ControllingPrim.PhysBody, CollisionFlags.BS_VEHICLE_COLLISIONS);
+                ControllingPrim.Linkset.AddToPhysicalCollisionFlags(CollisionFlags.BS_VEHICLE_COLLISIONS);
 
-                Prim.Inertia = PhysicsScene.PE.CalculateLocalInertia(Prim.PhysShape, m_vehicleMass);
-                PhysicsScene.PE.SetMassProps(Prim.PhysBody, m_vehicleMass, Prim.Inertia);
-                PhysicsScene.PE.UpdateInertiaTensor(Prim.PhysBody);
+                // 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.ComputeAndSetLocalInertia(BSParam.VehicleInertiaFactor, m_vehicleMass);
 
                 // Set the gravity for the vehicle depending on the buoyancy
                 // TODO: what should be done if prim and vehicle buoyancy differ?
-                m_VehicleGravity = Prim.ComputeGravity(m_VehicleBuoyancy);
+                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.
-                PhysicsScene.PE.SetGravity(Prim.PhysBody, Vector3.Zero);
+                // 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}",
-                        Prim.LocalID, m_vehicleMass, Prim.Inertia, m_VehicleGravity,
+                        ControllingPrim.LocalID, m_vehicleMass, ControllingPrim.Inertia, m_VehicleGravity,
                         BSParam.VehicleAngularDamping, BSParam.VehicleFriction, BSParam.VehicleRestitution,
                         BSParam.VehicleLinearFactor, BSParam.VehicleAngularFactor
                         );
             }
             else
             {
-                if (Prim.PhysBody.HasPhysicalBody)
-                    PhysicsScene.PE.RemoveFromCollisionFlags(Prim.PhysBody, CollisionFlags.BS_VEHICLE_COLLISIONS);
+                if (ControllingPrim.PhysBody.HasPhysicalBody)
+                    m_physicsScene.PE.RemoveFromCollisionFlags(ControllingPrim.PhysBody, CollisionFlags.BS_VEHICLE_COLLISIONS);
+                // ControllingPrim.Linkset.RemoveFromPhysicalCollisionFlags(CollisionFlags.BS_VEHICLE_COLLISIONS);
             }
         }
 
-        public bool RemoveBodyDependencies(BSPhysObject prim)
+        // BSActor.RemoveBodyDependencies
+        public override void RemoveDependencies()
         {
             Refresh();
-            return IsActive;
+        }
+
+        // BSActor.Release()
+        public override void Dispose()
+        {
+            VDetailLog("{0},Dispose", ControllingPrim.LocalID);
+            UnregisterForSceneEvents();
+            Type = Vehicle.TYPE_NONE;
+            Enabled = false;
+            return;
+        }
+
+        private void RegisterForSceneEvents()
+        {
+            if (!m_haveRegisteredForSceneEvents)
+            {
+                m_physicsScene.BeforeStep += this.Step;
+                m_physicsScene.AfterStep += this.PostStep;
+                ControllingPrim.OnPreUpdateProperty += this.PreUpdateProperty;
+                m_haveRegisteredForSceneEvents = true;
+            }
+        }
+
+        private void UnregisterForSceneEvents()
+        {
+            if (m_haveRegisteredForSceneEvents)
+            {
+                m_physicsScene.BeforeStep -= this.Step;
+                m_physicsScene.AfterStep -= this.PostStep;
+                ControllingPrim.OnPreUpdateProperty -= this.PreUpdateProperty;
+                m_haveRegisteredForSceneEvents = false;
+            }
+        }
+
+        private void PreUpdateProperty(ref EntityProperties entprop)
+        {
+            // A temporary kludge to suppress the rotational effects introduced on vehicles by Bullet
+            // TODO: handle physics introduced by Bullet with computed vehicle physics.
+            if (IsActive)
+            {
+                entprop.RotationalVelocity = Vector3.Zero;
+            }
         }
 
         #region Known vehicle value functions
@@ -661,7 +699,6 @@ namespace OpenSim.Region.Physics.BulletSPlugin
         private Vector3 m_knownRotationalVelocity;
         private Vector3 m_knownRotationalForce;
         private Vector3 m_knownRotationalImpulse;
-        private Vector3 m_knownForwardVelocity;    // vehicle relative forward speed
 
         private const int m_knownChangedPosition           = 1 << 0;
         private const int m_knownChangedVelocity           = 1 << 1;
@@ -673,7 +710,6 @@ namespace OpenSim.Region.Physics.BulletSPlugin
         private const int m_knownChangedRotationalImpulse  = 1 << 7;
         private const int m_knownChangedTerrainHeight      = 1 << 8;
         private const int m_knownChangedWaterLevel         = 1 << 9;
-        private const int m_knownChangedForwardVelocity    = 1 <<10;
 
         public void ForgetKnownVehicleProperties()
         {
@@ -686,14 +722,14 @@ namespace OpenSim.Region.Physics.BulletSPlugin
             if (m_knownChanged != 0)
             {
                 if ((m_knownChanged & m_knownChangedPosition) != 0)
-                    Prim.ForcePosition = m_knownPosition;
+                    ControllingPrim.ForcePosition = m_knownPosition;
 
                 if ((m_knownChanged & m_knownChangedOrientation) != 0)
-                    Prim.ForceOrientation = m_knownOrientation;
+                    ControllingPrim.ForceOrientation = m_knownOrientation;
 
                 if ((m_knownChanged & m_knownChangedVelocity) != 0)
                 {
-                    Prim.ForceVelocity = m_knownVelocity;
+                    ControllingPrim.ForceVelocity = m_knownVelocity;
                     // Fake out Bullet by making it think the velocity is the same as last time.
                     // Bullet does a bunch of smoothing for changing parameters.
                     //    Since the vehicle is demanding this setting, we override Bullet's smoothing
@@ -702,41 +738,41 @@ namespace OpenSim.Region.Physics.BulletSPlugin
                 }
 
                 if ((m_knownChanged & m_knownChangedForce) != 0)
-                    Prim.AddForce((Vector3)m_knownForce, false /*pushForce*/, true /*inTaintTime*/);
+                    ControllingPrim.AddForce((Vector3)m_knownForce, false /*pushForce*/, true /*inTaintTime*/);
 
                 if ((m_knownChanged & m_knownChangedForceImpulse) != 0)
-                    Prim.AddForceImpulse((Vector3)m_knownForceImpulse, false /*pushforce*/, true /*inTaintTime*/);
+                    ControllingPrim.AddForceImpulse((Vector3)m_knownForceImpulse, false /*pushforce*/, true /*inTaintTime*/);
 
                 if ((m_knownChanged & m_knownChangedRotationalVelocity) != 0)
                 {
-                    Prim.ForceRotationalVelocity = m_knownRotationalVelocity;
+                    ControllingPrim.ForceRotationalVelocity = m_knownRotationalVelocity;
                     // PhysicsScene.PE.SetInterpolationAngularVelocity(Prim.PhysBody, m_knownRotationalVelocity);
                 }
 
                 if ((m_knownChanged & m_knownChangedRotationalImpulse) != 0)
-                    Prim.ApplyTorqueImpulse((Vector3)m_knownRotationalImpulse, true /*inTaintTime*/);
+                    ControllingPrim.ApplyTorqueImpulse((Vector3)m_knownRotationalImpulse, true /*inTaintTime*/);
 
                 if ((m_knownChanged & m_knownChangedRotationalForce) != 0)
                 {
-                    Prim.AddAngularForce((Vector3)m_knownRotationalForce, false /*pushForce*/, true /*inTaintTime*/);
+                    ControllingPrim.AddAngularForce((Vector3)m_knownRotationalForce, false /*pushForce*/, true /*inTaintTime*/);
                 }
 
                 // If we set one of the values (ie, the physics engine didn't do it) we must force
                 //      an UpdateProperties event to send the changes up to the simulator.
-                PhysicsScene.PE.PushUpdate(Prim.PhysBody);
+                m_physicsScene.PE.PushUpdate(ControllingPrim.PhysBody);
             }
             m_knownChanged = 0;
         }
 
         // Since the computation of terrain height can be a little involved, this routine
         //    is used to fetch the height only once for each vehicle simulation step.
-        Vector3 lastRememberedHeightPos;
+        Vector3 lastRememberedHeightPos = new Vector3(-1, -1, -1);
         private float GetTerrainHeight(Vector3 pos)
         {
             if ((m_knownHas & m_knownChangedTerrainHeight) == 0 || pos != lastRememberedHeightPos)
             {
                 lastRememberedHeightPos = pos;
-                m_knownTerrainHeight = Prim.PhysicsScene.TerrainManager.GetTerrainHeightAtXYZ(pos);
+                m_knownTerrainHeight = ControllingPrim.PhysScene.TerrainManager.GetTerrainHeightAtXYZ(pos);
                 m_knownHas |= m_knownChangedTerrainHeight;
             }
             return m_knownTerrainHeight;
@@ -744,14 +780,16 @@ namespace OpenSim.Region.Physics.BulletSPlugin
 
         // Since the computation of water level can be a little involved, this routine
         //    is used ot fetch the level only once for each vehicle simulation step.
+        Vector3 lastRememberedWaterHeightPos = new Vector3(-1, -1, -1);
         private float GetWaterLevel(Vector3 pos)
         {
-            if ((m_knownHas & m_knownChangedWaterLevel) == 0)
+            if ((m_knownHas & m_knownChangedWaterLevel) == 0 || pos != lastRememberedWaterHeightPos)
             {
-                m_knownWaterLevel = Prim.PhysicsScene.TerrainManager.GetWaterLevelAtXYZ(pos);
+                lastRememberedWaterHeightPos = pos;
+                m_knownWaterLevel = ControllingPrim.PhysScene.TerrainManager.GetWaterLevelAtXYZ(pos);
                 m_knownHas |= m_knownChangedWaterLevel;
             }
-            return (float)m_knownWaterLevel;
+            return m_knownWaterLevel;
         }
 
         private Vector3 VehiclePosition
@@ -760,7 +798,7 @@ namespace OpenSim.Region.Physics.BulletSPlugin
             {
                 if ((m_knownHas & m_knownChangedPosition) == 0)
                 {
-                    m_knownPosition = Prim.ForcePosition;
+                    m_knownPosition = ControllingPrim.ForcePosition;
                     m_knownHas |= m_knownChangedPosition;
                 }
                 return m_knownPosition;
@@ -779,7 +817,7 @@ namespace OpenSim.Region.Physics.BulletSPlugin
             {
                 if ((m_knownHas & m_knownChangedOrientation) == 0)
                 {
-                    m_knownOrientation = Prim.ForceOrientation;
+                    m_knownOrientation = ControllingPrim.ForceOrientation;
                     m_knownHas |= m_knownChangedOrientation;
                 }
                 return m_knownOrientation;
@@ -798,7 +836,7 @@ namespace OpenSim.Region.Physics.BulletSPlugin
             {
                 if ((m_knownHas & m_knownChangedVelocity) == 0)
                 {
-                    m_knownVelocity = Prim.ForceVelocity;
+                    m_knownVelocity = ControllingPrim.ForceVelocity;
                     m_knownHas |= m_knownChangedVelocity;
                 }
                 return m_knownVelocity;
@@ -839,7 +877,7 @@ namespace OpenSim.Region.Physics.BulletSPlugin
             {
                 if ((m_knownHas & m_knownChangedRotationalVelocity) == 0)
                 {
-                    m_knownRotationalVelocity = Prim.ForceRotationalVelocity;
+                    m_knownRotationalVelocity = ControllingPrim.ForceRotationalVelocity;
                     m_knownHas |= m_knownChangedRotationalVelocity;
                 }
                 return (Vector3)m_knownRotationalVelocity;
@@ -877,14 +915,10 @@ namespace OpenSim.Region.Physics.BulletSPlugin
         {
             get
             {
-                if ((m_knownHas & m_knownChangedForwardVelocity) == 0)
-                {
-                    m_knownForwardVelocity = VehicleVelocity * Quaternion.Inverse(Quaternion.Normalize(VehicleOrientation));
-                    m_knownHas |= m_knownChangedForwardVelocity;
-                }
-                return m_knownForwardVelocity;
+                return VehicleVelocity * Quaternion.Inverse(Quaternion.Normalize(VehicleOrientation));
             }
         }
+
         private float VehicleForwardSpeed
         {
             get
@@ -914,11 +948,11 @@ namespace OpenSim.Region.Physics.BulletSPlugin
             //      for the physics engine to note the changes so an UpdateProperties event will happen.
             PushKnownChanged();
 
-            if (PhysicsScene.VehiclePhysicalLoggingEnabled)
-                PhysicsScene.PE.DumpRigidBody(PhysicsScene.World, Prim.PhysBody);
+            if (m_physicsScene.VehiclePhysicalLoggingEnabled)
+                m_physicsScene.PE.DumpRigidBody(m_physicsScene.World, ControllingPrim.PhysBody);
 
             VDetailLog("{0},BSDynamics.Step,done,pos={1}, force={2},velocity={3},angvel={4}",
-                    Prim.LocalID, VehiclePosition, m_knownForce, VehicleVelocity, VehicleRotationalVelocity);
+                    ControllingPrim.LocalID, VehiclePosition, m_knownForce, VehicleVelocity, VehicleRotationalVelocity);
         }
 
         // Called after the simulation step
@@ -926,8 +960,8 @@ namespace OpenSim.Region.Physics.BulletSPlugin
         {
             if (!IsActive) return;
 
-            if (PhysicsScene.VehiclePhysicalLoggingEnabled)
-                PhysicsScene.PE.DumpRigidBody(PhysicsScene.World, Prim.PhysBody);
+            if (m_physicsScene.VehiclePhysicalLoggingEnabled)
+                m_physicsScene.PE.DumpRigidBody(m_physicsScene.World, ControllingPrim.PhysBody);
         }
 
         // Apply the effect of the linear motor and other linear motions (like hover and float).
@@ -935,6 +969,8 @@ namespace OpenSim.Region.Physics.BulletSPlugin
         {
             ComputeLinearVelocity(pTimestep);
 
+            ComputeLinearDeflection(pTimestep);
+
             ComputeLinearTerrainHeightCorrection(pTimestep);
 
             ComputeLinearHover(pTimestep);
@@ -950,11 +986,17 @@ namespace OpenSim.Region.Physics.BulletSPlugin
             {
                 Vector3 vel = VehicleVelocity;
                 if ((m_flags & (VehicleFlag.NO_X)) != 0)
+                {
                     vel.X = 0;
+                }
                 if ((m_flags & (VehicleFlag.NO_Y)) != 0)
+                {
                     vel.Y = 0;
+                }
                 if ((m_flags & (VehicleFlag.NO_Z)) != 0)
+                {
                     vel.Z = 0;
+                }
                 VehicleVelocity = vel;
             }
 
@@ -966,13 +1008,13 @@ namespace OpenSim.Region.Physics.BulletSPlugin
                 Vector3 origVelW = VehicleVelocity;         // DEBUG DEBUG
                 VehicleVelocity /= VehicleVelocity.Length();
                 VehicleVelocity *= BSParam.VehicleMaxLinearVelocity;
-                VDetailLog("{0},  MoveLinear,clampMax,origVelW={1},lenSq={2},maxVelSq={3},,newVelW={4}", 
-                            Prim.LocalID, origVelW, newVelocityLengthSq, BSParam.VehicleMaxLinearVelocitySquared, VehicleVelocity);
+                VDetailLog("{0},  MoveLinear,clampMax,origVelW={1},lenSq={2},maxVelSq={3},,newVelW={4}",
+                            ControllingPrim.LocalID, origVelW, newVelocityLengthSq, BSParam.VehicleMaxLinearVelocitySquared, VehicleVelocity);
             }
             else if (newVelocityLengthSq < 0.001f)
                 VehicleVelocity = Vector3.Zero;
 
-            VDetailLog("{0},  MoveLinear,done,isColl={1},newVel={2}", Prim.LocalID, Prim.IsColliding, VehicleVelocity );
+            VDetailLog("{0},  MoveLinear,done,isColl={1},newVel={2}", ControllingPrim.LocalID, ControllingPrim.HasSomeCollision, VehicleVelocity );
 
         } // end MoveLinear()
 
@@ -980,9 +1022,13 @@ namespace OpenSim.Region.Physics.BulletSPlugin
         {
             // Step the motor from the current value. Get the correction needed this step.
             Vector3 origVelW = VehicleVelocity;             // DEBUG
-            Vector3 currentVelV = VehicleVelocity * Quaternion.Inverse(VehicleOrientation);
+            Vector3 currentVelV = VehicleForwardVelocity;
             Vector3 linearMotorCorrectionV = m_linearMotor.Step(pTimestep, currentVelV);
 
+            // Friction reduces vehicle motion based on absolute speed. Slow vehicle down by friction.
+            Vector3 frictionFactorV = ComputeFrictionFactor(m_linearFrictionTimescale, pTimestep);
+            linearMotorCorrectionV -= (currentVelV * frictionFactorV);
+
             // Motor is vehicle coordinates. Rotate it to world coordinates
             Vector3 linearMotorVelocityW = linearMotorCorrectionV * VehicleOrientation;
 
@@ -996,8 +1042,49 @@ 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}",
-                        Prim.LocalID, origVelW, currentVelV, linearMotorCorrectionV, linearMotorVelocityW, VehicleVelocity);
+            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);
+        }
+
+        //Given a Deflection Effiency and a Velocity, Returns a Velocity that is Partially Deflected onto the X Axis
+        //Clamped so that a DeflectionTimescale of less then 1 does not increase force over original velocity
+        private void ComputeLinearDeflection(float pTimestep)
+        {
+            Vector3 linearDeflectionV = Vector3.Zero;
+            Vector3 velocityV = VehicleForwardVelocity;
+
+            if (BSParam.VehicleEnableLinearDeflection)
+            {
+                // Velocity in Y and Z dimensions is movement to the side or turning.
+                // Compute deflection factor from the to the side and rotational velocity
+                linearDeflectionV.Y = SortedClampInRange(0, (velocityV.Y * m_linearDeflectionEfficiency) / m_linearDeflectionTimescale, velocityV.Y);
+                linearDeflectionV.Z = SortedClampInRange(0, (velocityV.Z * m_linearDeflectionEfficiency) / m_linearDeflectionTimescale, velocityV.Z);
+
+                // Velocity to the side and around is corrected and moved into the forward direction
+                linearDeflectionV.X += Math.Abs(linearDeflectionV.Y);
+                linearDeflectionV.X += Math.Abs(linearDeflectionV.Z);
+
+                // Scale the deflection to the fractional simulation time
+                linearDeflectionV *= pTimestep;
+
+                // Subtract the sideways and rotational velocity deflection factors while adding the correction forward
+                linearDeflectionV *= new Vector3(1, -1, -1);
+
+                // Correction is vehicle relative. Convert to world coordinates.
+                Vector3 linearDeflectionW = linearDeflectionV * VehicleOrientation;
+
+                // Optionally, if not colliding, don't effect world downward velocity. Let falling things fall.
+                if (BSParam.VehicleLinearDeflectionNotCollidingNoZ && !m_controllingPrim.HasSomeCollision)
+                {
+                    linearDeflectionW.Z = 0f;
+                }
+
+                VehicleVelocity += linearDeflectionW;
+
+                VDetailLog("{0},  MoveLinear,LinearDeflection,linDefEff={1},linDefTS={2},linDeflectionV={3}",
+                            ControllingPrim.LocalID, m_linearDeflectionEfficiency, m_linearDeflectionTimescale, linearDeflectionV);
+            }
         }
 
         public void ComputeLinearTerrainHeightCorrection(float pTimestep)
@@ -1011,7 +1098,7 @@ namespace OpenSim.Region.Physics.BulletSPlugin
                 newPosition.Z = GetTerrainHeight(VehiclePosition) + 1f;
                 VehiclePosition = newPosition;
                 VDetailLog("{0},  MoveLinear,terrainHeight,terrainHeight={1},pos={2}",
-                        Prim.LocalID, GetTerrainHeight(VehiclePosition), VehiclePosition);
+                        ControllingPrim.LocalID, GetTerrainHeight(VehiclePosition), VehiclePosition);
             }
         }
 
@@ -1034,14 +1121,25 @@ namespace OpenSim.Region.Physics.BulletSPlugin
                 {
                     m_VhoverTargetHeight = m_VhoverHeight;
                 }
-
                 if ((m_flags & VehicleFlag.HOVER_UP_ONLY) != 0)
                 {
                     // If body is already heigher, use its height as target height
                     if (VehiclePosition.Z > m_VhoverTargetHeight)
+                    {
                         m_VhoverTargetHeight = VehiclePosition.Z;
+
+                        // A 'misfeature' of this flag is that if the vehicle is above it's hover height,
+                        //     the vehicle's buoyancy goes away. This is an SL bug that got used by so many
+                        //    scripts that it could not be changed.
+                        // So, if above the height, reapply gravity if buoyancy had it turned off.
+                        if (m_VehicleBuoyancy != 0)
+                        {
+                            Vector3 appliedGravity = ControllingPrim.ComputeGravity(ControllingPrim.Buoyancy) * m_vehicleMass;
+                            VehicleAddForce(appliedGravity);
+                        }
+                    }
                 }
-                
+
                 if ((m_flags & VehicleFlag.LOCK_HOVER_HEIGHT) != 0)
                 {
                     if (Math.Abs(VehiclePosition.Z - m_VhoverTargetHeight) > 0.2f)
@@ -1050,7 +1148,7 @@ namespace OpenSim.Region.Physics.BulletSPlugin
                         pos.Z = m_VhoverTargetHeight;
                         VehiclePosition = pos;
 
-                        VDetailLog("{0},  MoveLinear,hover,pos={1},lockHoverHeight", Prim.LocalID, pos);
+                        VDetailLog("{0},  MoveLinear,hover,pos={1},lockHoverHeight", ControllingPrim.LocalID, pos);
                     }
                 }
                 else
@@ -1079,11 +1177,10 @@ namespace OpenSim.Region.Physics.BulletSPlugin
                      */
 
                     VDetailLog("{0},  MoveLinear,hover,pos={1},eff={2},hoverTS={3},height={4},target={5},err={6},corr={7}",
-                                    Prim.LocalID, VehiclePosition, m_VhoverEfficiency,
+                                    ControllingPrim.LocalID, VehiclePosition, m_VhoverEfficiency,
                                     m_VhoverTimescale, m_VhoverHeight, m_VhoverTargetHeight,
                                     verticalError, verticalCorrection);
                 }
-
             }
         }
 
@@ -1124,7 +1221,7 @@ namespace OpenSim.Region.Physics.BulletSPlugin
                 {
                     VehiclePosition = pos;
                     VDetailLog("{0},  MoveLinear,blockingEndPoint,block={1},origPos={2},pos={3}",
-                                Prim.LocalID, m_BlockingEndPoint, posChange, pos);
+                                ControllingPrim.LocalID, m_BlockingEndPoint, posChange, pos);
                 }
             }
             return changed;
@@ -1135,7 +1232,7 @@ namespace OpenSim.Region.Physics.BulletSPlugin
         //    used with conjunction with banking: the strength of the banking will decay when the
         //    vehicle no longer experiences collisions. The decay timescale is the same as
         //    VEHICLE_BANKING_TIMESCALE. This is to help prevent ground vehicles from steering
-        //    when they are in mid jump. 
+        //    when they are in mid jump.
         // TODO: this code is wrong. Also, what should it do for boats (height from water)?
         //    This is just using the ground and a general collision check. Should really be using
         //    a downward raycast to find what is below.
@@ -1148,7 +1245,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);
@@ -1159,12 +1256,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 (!Prim.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;
@@ -1186,7 +1283,7 @@ namespace OpenSim.Region.Physics.BulletSPlugin
                     }
                         */
                     VDetailLog("{0},  MoveLinear,limitMotorUp,collide={1},upVel={2},newVel={3}",
-                                    Prim.LocalID, Prim.IsColliding, upVelocity, VehicleVelocity);
+                                    ControllingPrim.LocalID, ControllingPrim.HasSomeCollision, upVelocity, VehicleVelocity);
                 }
             }
         }
@@ -1196,14 +1293,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 (Prim.IsColliding && IsGroundVehicle)
+            if (ControllingPrim.HasSomeCollision && IsGroundVehicle)
                 appliedGravity *= BSParam.VehicleGroundGravityFudge;
 
             VehicleAddForce(appliedGravity);
 
-            VDetailLog("{0},  MoveLinear,applyGravity,vehGrav={1},collid={2},fudge={3},mass={4},appliedForce={3}", 
-                            Prim.LocalID, m_VehicleGravity,
-                            Prim.IsColliding, BSParam.VehicleGroundGravityFudge, m_vehicleMass, appliedGravity);
+            VDetailLog("{0},  MoveLinear,applyGravity,vehGrav={1},collid={2},fudge={3},mass={4},appliedForce={5}",
+                            ControllingPrim.LocalID, m_VehicleGravity,
+                            ControllingPrim.HasSomeCollision, BSParam.VehicleGroundGravityFudge, m_vehicleMass, appliedGravity);
         }
 
         // =======================================================================
@@ -1227,11 +1324,11 @@ namespace OpenSim.Region.Physics.BulletSPlugin
             {
                 // The vehicle is not adding anything angular wise.
                 VehicleRotationalVelocity = Vector3.Zero;
-                VDetailLog("{0},  MoveAngular,done,zero", Prim.LocalID);
+                VDetailLog("{0},  MoveAngular,done,zero", ControllingPrim.LocalID);
             }
             else
             {
-                VDetailLog("{0},  MoveAngular,done,nonZero,angVel={1}", Prim.LocalID, VehicleRotationalVelocity);
+                VDetailLog("{0},  MoveAngular,done,nonZero,angVel={1}", ControllingPrim.LocalID, VehicleRotationalVelocity);
             }
 
             // ==================================================================
@@ -1262,7 +1359,7 @@ namespace OpenSim.Region.Physics.BulletSPlugin
                     torqueFromOffset.Z = 0;
 
                 VehicleAddAngularForce(torqueFromOffset * m_vehicleMass);
-                VDetailLog("{0},  BSDynamic.MoveAngular,motorOffset,applyTorqueImpulse={1}", Prim.LocalID, torqueFromOffset);
+                VDetailLog("{0},  BSDynamic.MoveAngular,motorOffset,applyTorqueImpulse={1}", ControllingPrim.LocalID, torqueFromOffset);
             }
 
         }
@@ -1270,6 +1367,7 @@ namespace OpenSim.Region.Physics.BulletSPlugin
         private void ComputeAngularTurning(float pTimestep)
         {
             // The user wants this many radians per second angular change?
+            Vector3 origVehicleRotationalVelocity = VehicleRotationalVelocity;      // DEBUG DEBUG
             Vector3 currentAngularV = VehicleRotationalVelocity * Quaternion.Inverse(VehicleOrientation);
             Vector3 angularMotorContributionV = m_angularMotor.Step(pTimestep, currentAngularV);
 
@@ -1277,18 +1375,25 @@ namespace OpenSim.Region.Physics.BulletSPlugin
             // From http://wiki.secondlife.com/wiki/LlSetVehicleFlags :
             //    This flag prevents linear deflection parallel to world z-axis. This is useful
             //    for preventing ground vehicles with large linear deflection, like bumper cars,
-            //    from climbing their linear deflection into the sky. 
+            //    from climbing their linear deflection into the sky.
             // That is, NO_DEFLECTION_UP says angular motion should not add any pitch or roll movement
             // TODO: This is here because this is where ODE put it but documentation says it
             //    is a linear effect. Where should this check go?
             //if ((m_flags & (VehicleFlag.NO_DEFLECTION_UP)) != 0)
-           // {
+            // {
             //    angularMotorContributionV.X = 0f;
             //    angularMotorContributionV.Y = 0f;
-          //  }
+            //  }
+
+            // Reduce any velocity by friction.
+            Vector3 frictionFactorW = ComputeFrictionFactor(m_angularFrictionTimescale, pTimestep);
+            angularMotorContributionV -= (currentAngularV * frictionFactorW);
+
+            Vector3 angularMotorContributionW = angularMotorContributionV * VehicleOrientation;
+            VehicleRotationalVelocity += angularMotorContributionW;
 
-            VehicleRotationalVelocity += angularMotorContributionV * VehicleOrientation;
-            VDetailLog("{0},  MoveAngular,angularTurning,angularMotorContrib={1}", Prim.LocalID, angularMotorContributionV);
+            VDetailLog("{0},  MoveAngular,angularTurning,curAngVelV={1},origVehRotVel={2},vehRotVel={3},frictFact={4}, angContribV={5},angContribW={6}",
+                        ControllingPrim.LocalID, currentAngularV, origVehicleRotationalVelocity, VehicleRotationalVelocity, frictionFactorW, angularMotorContributionV, angularMotorContributionW);
         }
 
         // From http://wiki.secondlife.com/wiki/Linden_Vehicle_Tutorial:
@@ -1303,86 +1408,136 @@ namespace OpenSim.Region.Physics.BulletSPlugin
         {
 
             // If vertical attaction timescale is reasonable
-            if (enableAngularVerticalAttraction && m_verticalAttractionTimescale < m_verticalAttractionCutoff)
+            if (BSParam.VehicleEnableAngularVerticalAttraction && m_verticalAttractionTimescale < m_verticalAttractionCutoff)
             {
-                // Possible solution derived from a discussion at:
-                // http://stackoverflow.com/questions/14939657/computing-vector-from-quaternion-works-computing-quaternion-from-vector-does-no
-
-                // Create a rotation that is only the vehicle's rotation around Z
-                Vector3 currentEuler = Vector3.Zero;
-                VehicleOrientation.GetEulerAngles(out currentEuler.X, out currentEuler.Y, out currentEuler.Z);
-                Quaternion justZOrientation = Quaternion.CreateFromAxisAngle(Vector3.UnitZ, currentEuler.Z);
-
-                // Create the axis that is perpendicular to the up vector and the rotated up vector.
-                Vector3 differenceAxis = Vector3.Cross(Vector3.UnitZ * justZOrientation, Vector3.UnitZ * VehicleOrientation);
-                // Compute the angle between those to vectors.
-                double differenceAngle = Math.Acos((double)Vector3.Dot(Vector3.UnitZ, Vector3.Normalize(Vector3.UnitZ * VehicleOrientation)));
-                // 'differenceAngle' is the angle to rotate and 'differenceAxis' is the plane to rotate in to get the vehicle vertical
-
-                // Reduce the change by the time period it is to change in. Timestep is handled when velocity is applied.
-                // TODO: add 'efficiency'.
-                differenceAngle /= m_verticalAttractionTimescale;
-
-                // Create the quaterian representing the correction angle
-                Quaternion correctionRotation = Quaternion.CreateFromAxisAngle(differenceAxis, (float)differenceAngle);
-
-                // Turn that quaternion into Euler values to make it into velocities to apply.
-                Vector3 vertContributionV = Vector3.Zero;
-                correctionRotation.GetEulerAngles(out vertContributionV.X, out vertContributionV.Y, out vertContributionV.Z);
-                vertContributionV *= -1f;
-
-                VehicleRotationalVelocity += vertContributionV;
-
-                VDetailLog("{0},  MoveAngular,verticalAttraction,diffAxis={1},diffAng={2},corrRot={3},contrib={4}",
-                                Prim.LocalID,
-                                differenceAxis,
-                                differenceAngle,
-                                correctionRotation,
-                                vertContributionV);
-
-                // ===================================================================
-                /*
-                Vector3 vertContributionV = Vector3.Zero;
-                Vector3 origRotVelW = VehicleRotationalVelocity;        // DEBUG DEBUG
-
-                // Take a vector pointing up and convert it from world to vehicle relative coords.
-                Vector3 verticalError = Vector3.Normalize(Vector3.UnitZ * VehicleOrientation);
-
-                // If vertical attraction correction is needed, the vector that was pointing up (UnitZ)
-                //    is now:
-                //    leaning to one side: rotated around the X axis with the Y value going
-                //        from zero (nearly straight up) to one (completely to the side)) or
-                //    leaning front-to-back: rotated around the Y axis with the value of X being between
-                //         zero and one.
-                // The value of Z is how far the rotation is off with 1 meaning none and 0 being 90 degrees.
-
-                // Y error means needed rotation around X axis and visa versa.
-                // Since the error goes from zero to one, the asin is the corresponding angle.
-                vertContributionV.X = (float)Math.Asin(verticalError.Y);
-                // (Tilt forward (positive X) needs to tilt back (rotate negative) around Y axis.)
-                vertContributionV.Y = -(float)Math.Asin(verticalError.X);
-
-                // If verticalError.Z is negative, the vehicle is upside down. Add additional push.
-                if (verticalError.Z < 0f)
+                Vector3 vehicleUpAxis = Vector3.UnitZ * VehicleOrientation;
+                switch (BSParam.VehicleAngularVerticalAttractionAlgorithm)
                 {
-                    vertContributionV.X += Math.Sign(vertContributionV.X) * PIOverFour;
-                    // vertContribution.Y -= PIOverFour;
+                    case 0:
+                        {
+                            //Another formula to try got from :
+                            //http://answers.unity3d.com/questions/10425/how-to-stabilize-angular-motion-alignment-of-hover.html
+
+                            // Flipping what was originally a timescale into a speed variable and then multiplying it by 2
+                            //    since only computing half the distance between the angles.
+                            float verticalAttractionSpeed = (1 / m_verticalAttractionTimescale) * 2.0f;
+
+                            // Make a prediction of where the up axis will be when this is applied rather then where it is now as
+                            //     this makes for a smoother adjustment and less fighting between the various forces.
+                            Vector3 predictedUp = vehicleUpAxis * Quaternion.CreateFromAxisAngle(VehicleRotationalVelocity, 0f);
+
+                            // This is only half the distance to the target so it will take 2 seconds to complete the turn.
+                            Vector3 torqueVector = Vector3.Cross(predictedUp, Vector3.UnitZ);
+
+                            // Scale vector by our timescale since it is an acceleration it is r/s^2 or radians a timescale squared
+                            Vector3 vertContributionV = torqueVector * verticalAttractionSpeed * verticalAttractionSpeed;
+
+                            VehicleRotationalVelocity += vertContributionV;
+
+                            VDetailLog("{0},  MoveAngular,verticalAttraction,vertAttrSpeed={1},upAxis={2},PredictedUp={3},torqueVector={4},contrib={5}",
+                                            ControllingPrim.LocalID,
+                                            verticalAttractionSpeed,
+                                            vehicleUpAxis,
+                                            predictedUp,
+                                            torqueVector,
+                                            vertContributionV);
+                            break;
+                        }
+                    case 1:
+                        {
+                            // Possible solution derived from a discussion at:
+                            // http://stackoverflow.com/questions/14939657/computing-vector-from-quaternion-works-computing-quaternion-from-vector-does-no
+
+                            // Create a rotation that is only the vehicle's rotation around Z
+                            Vector3 currentEulerW = Vector3.Zero;
+                            VehicleOrientation.GetEulerAngles(out currentEulerW.X, out currentEulerW.Y, out currentEulerW.Z);
+                            Quaternion justZOrientation = Quaternion.CreateFromAxisAngle(Vector3.UnitZ, currentEulerW.Z);
+
+                            // Create the axis that is perpendicular to the up vector and the rotated up vector.
+                            Vector3 differenceAxisW = Vector3.Cross(Vector3.UnitZ * justZOrientation, Vector3.UnitZ * VehicleOrientation);
+                            // Compute the angle between those to vectors.
+                            double differenceAngle = Math.Acos((double)Vector3.Dot(Vector3.UnitZ, Vector3.Normalize(Vector3.UnitZ * VehicleOrientation)));
+                            // 'differenceAngle' is the angle to rotate and 'differenceAxis' is the plane to rotate in to get the vehicle vertical
+
+                            // Reduce the change by the time period it is to change in. Timestep is handled when velocity is applied.
+                            // TODO: add 'efficiency'.
+                            // differenceAngle /= m_verticalAttractionTimescale;
+
+                            // Create the quaterian representing the correction angle
+                            Quaternion correctionRotationW = Quaternion.CreateFromAxisAngle(differenceAxisW, (float)differenceAngle);
+
+                            // Turn that quaternion into Euler values to make it into velocities to apply.
+                            Vector3 vertContributionW = Vector3.Zero;
+                            correctionRotationW.GetEulerAngles(out vertContributionW.X, out vertContributionW.Y, out vertContributionW.Z);
+                            vertContributionW *= -1f;
+                            vertContributionW /= m_verticalAttractionTimescale;
+
+                            VehicleRotationalVelocity += vertContributionW;
+
+                            VDetailLog("{0},  MoveAngular,verticalAttraction,upAxis={1},diffAxis={2},diffAng={3},corrRot={4},contrib={5}",
+                                            ControllingPrim.LocalID,
+                                            vehicleUpAxis,
+                                            differenceAxisW,
+                                            differenceAngle,
+                                            correctionRotationW,
+                                            vertContributionW);
+                            break;
+                        }
+                    case 2:
+                        {
+                            Vector3 vertContributionV = Vector3.Zero;
+                            Vector3 origRotVelW = VehicleRotationalVelocity;        // DEBUG DEBUG
+
+                            // Take a vector pointing up and convert it from world to vehicle relative coords.
+                            Vector3 verticalError = Vector3.Normalize(Vector3.UnitZ * VehicleOrientation);
+
+                            // If vertical attraction correction is needed, the vector that was pointing up (UnitZ)
+                            //    is now:
+                            //    leaning to one side: rotated around the X axis with the Y value going
+                            //        from zero (nearly straight up) to one (completely to the side)) or
+                            //    leaning front-to-back: rotated around the Y axis with the value of X being between
+                            //         zero and one.
+                            // The value of Z is how far the rotation is off with 1 meaning none and 0 being 90 degrees.
+
+                            // Y error means needed rotation around X axis and visa versa.
+                            // Since the error goes from zero to one, the asin is the corresponding angle.
+                            vertContributionV.X = (float)Math.Asin(verticalError.Y);
+                            // (Tilt forward (positive X) needs to tilt back (rotate negative) around Y axis.)
+                            vertContributionV.Y = -(float)Math.Asin(verticalError.X);
+
+                            // If verticalError.Z is negative, the vehicle is upside down. Add additional push.
+                            if (verticalError.Z < 0f)
+                            {
+                                vertContributionV.X += Math.Sign(vertContributionV.X) * PIOverFour;
+                                // vertContribution.Y -= PIOverFour;
+                            }
+
+                            // 'vertContrbution' is now the necessary angular correction to correct tilt in one second.
+                            //     Correction happens over a number of seconds.
+                            Vector3 unscaledContribVerticalErrorV = vertContributionV;     // DEBUG DEBUG
+
+                            // The correction happens over the user's time period
+                            vertContributionV /= m_verticalAttractionTimescale;
+
+                            // Rotate the vehicle rotation to the world coordinates.
+                            VehicleRotationalVelocity += (vertContributionV * VehicleOrientation);
+
+                            VDetailLog("{0},  MoveAngular,verticalAttraction,,upAxis={1},origRotVW={2},vertError={3},unscaledV={4},eff={5},ts={6},vertContribV={7}",
+                                            ControllingPrim.LocalID,
+                                            vehicleUpAxis,
+                                            origRotVelW,
+                                            verticalError,
+                                            unscaledContribVerticalErrorV,
+                                            m_verticalAttractionEfficiency,
+                                            m_verticalAttractionTimescale,
+                                            vertContributionV);
+                            break;
+                        }
+                    default:
+                        {
+                            break;
+                        }
                 }
-
-                // 'vertContrbution' is now the necessary angular correction to correct tilt in one second.
-                //     Correction happens over a number of seconds.
-                Vector3 unscaledContribVerticalErrorV = vertContributionV;     // DEBUG DEBUG
-
-                // The correction happens over the user's time period
-                vertContributionV /= m_verticalAttractionTimescale;
-
-                // Rotate the vehicle rotation to the world coordinates.
-                VehicleRotationalVelocity += (vertContributionV * VehicleOrientation);
-
-                VDetailLog("{0},  MoveAngular,verticalAttraction,,origRotVW={1},vertError={2},unscaledV={3},eff={4},ts={5},vertContribV={6}",
-                                Prim.LocalID, origRotVelW, verticalError, unscaledContribVerticalErrorV, 
-                                m_verticalAttractionEfficiency, m_verticalAttractionTimescale, vertContributionV);
-                */
             }
         }
 
@@ -1392,13 +1547,9 @@ namespace OpenSim.Region.Physics.BulletSPlugin
         //     in that direction.
         // TODO: implement reference frame.
         public void ComputeAngularDeflection()
-        {
-            // Since angularMotorUp and angularDeflection are computed independently, they will calculate
-            //     approximately the same X or Y correction. When added together (when contributions are combined)
-            //     this creates an over-correction and then wabbling as the target is overshot.
-            // TODO: rethink how the different correction computations inter-relate.
+        {   
 
-            if (enableAngularDeflection && m_angularDeflectionEfficiency != 0 && VehicleForwardSpeed > 0.2)
+            if (BSParam.VehicleEnableAngularDeflection && m_angularDeflectionEfficiency != 0 && VehicleForwardSpeed > 0.2)
             {
                 Vector3 deflectContributionV = Vector3.Zero;
 
@@ -1411,10 +1562,14 @@ namespace OpenSim.Region.Physics.BulletSPlugin
 
                 // The direction the vehicle is pointing
                 Vector3 pointingDirection = Vector3.UnitX * VehicleOrientation;
-                pointingDirection.Normalize();
+                //Predict where the Vehicle will be pointing after AngularVelocity change is applied. This will keep
+                //   from overshooting and allow this correction to merge with the Vertical Attraction peacefully.
+                Vector3 predictedPointingDirection = pointingDirection * Quaternion.CreateFromAxisAngle(VehicleRotationalVelocity, 0f);
+                predictedPointingDirection.Normalize();
 
                 // The difference between what is and what should be.
-                Vector3 deflectionError = movingDirection - pointingDirection;
+               // Vector3 deflectionError = movingDirection - predictedPointingDirection;
+                Vector3 deflectionError = Vector3.Cross(movingDirection, predictedPointingDirection);
 
                 // Don't try to correct very large errors (not our job)
                 // if (Math.Abs(deflectionError.X) > PIOverFour) deflectionError.X = PIOverTwo * Math.Sign(deflectionError.X);
@@ -1427,15 +1582,16 @@ namespace OpenSim.Region.Physics.BulletSPlugin
                 // ret = m_angularDeflectionCorrectionMotor(1f, deflectionError);
 
                 // Scale the correction by recovery timescale and efficiency
-                deflectContributionV = (-deflectionError) * m_angularDeflectionEfficiency;
-                deflectContributionV /= m_angularDeflectionTimescale;
-
-                VehicleRotationalVelocity += deflectContributionV * VehicleOrientation;
+                //    Not modeling a spring so clamp the scale to no more then the arc
+                deflectContributionV = (-deflectionError) * ClampInRange(0, m_angularDeflectionEfficiency/m_angularDeflectionTimescale,1f);
+                //deflectContributionV /= m_angularDeflectionTimescale;
 
+               // VehicleRotationalVelocity += deflectContributionV * VehicleOrientation;
+                VehicleRotationalVelocity += deflectContributionV;
                 VDetailLog("{0},  MoveAngular,Deflection,movingDir={1},pointingDir={2},deflectError={3},ret={4}",
-                    Prim.LocalID, movingDirection, pointingDirection, deflectionError, deflectContributionV);
-                VDetailLog("{0},  MoveAngular,Deflection,fwdSpd={1},defEff={2},defTS={3}",
-                    Prim.LocalID, VehicleForwardSpeed, m_angularDeflectionEfficiency, m_angularDeflectionTimescale);
+                    ControllingPrim.LocalID, movingDirection, pointingDirection, deflectionError, deflectContributionV);
+                VDetailLog("{0},  MoveAngular,Deflection,fwdSpd={1},defEff={2},defTS={3},PredictedPointingDir={4}",
+                    ControllingPrim.LocalID, VehicleForwardSpeed, m_angularDeflectionEfficiency, m_angularDeflectionTimescale, predictedPointingDirection);
             }
         }
 
@@ -1447,13 +1603,13 @@ namespace OpenSim.Region.Physics.BulletSPlugin
         //      produce a angular velocity around the yaw-axis, causing the vehicle to turn. The magnitude
         //      of the yaw effect will be proportional to the
         //          VEHICLE_BANKING_EFFICIENCY, the angle of the roll rotation, and sometimes the vehicle's
-        //                 velocity along its preferred axis of motion. 
+        //                 velocity along its preferred axis of motion.
         //          The VEHICLE_BANKING_EFFICIENCY can vary between -1 and +1. When it is positive then any
         //                  positive rotation (by the right-hand rule) about the roll-axis will effect a
         //                  (negative) torque around the yaw-axis, making it turn to the right--that is the
         //                  vehicle will lean into the turn, which is how real airplanes and motorcycle's work.
         //                  Negating the banking coefficient will make it so that the vehicle leans to the
-        //                  outside of the turn (not very "physical" but might allow interesting vehicles so why not?). 
+        //                  outside of the turn (not very "physical" but might allow interesting vehicles so why not?).
         //           The VEHICLE_BANKING_MIX is a fake (i.e. non-physical) parameter that is useful for making
         //                  banking vehicles do what you want rather than what the laws of physics allow.
         //                  For example, consider a real motorcycle...it must be moving forward in order for
@@ -1465,14 +1621,14 @@ namespace OpenSim.Region.Physics.BulletSPlugin
         //                  totally static (0.0) and totally dynamic (1.0). By "static" we mean that the
         //                  banking effect depends only on the vehicle's rotation about its roll-axis compared
         //                  to "dynamic" where the banking is also proportional to its velocity along its
-        //                  roll-axis. Finding the best value of the "mixture" will probably require trial and error. 
+        //                  roll-axis. Finding the best value of the "mixture" will probably require trial and error.
         //      The time it takes for the banking behavior to defeat a preexisting angular velocity about the
         //      world z-axis is determined by the VEHICLE_BANKING_TIMESCALE. So if you want the vehicle to
         //      bank quickly then give it a banking timescale of about a second or less, otherwise you can
-        //      make a sluggish vehicle by giving it a timescale of several seconds. 
+        //      make a sluggish vehicle by giving it a timescale of several seconds.
         public void ComputeAngularBanking()
         {
-            if (enableAngularBanking && m_bankingEfficiency != 0 && m_verticalAttractionTimescale < m_verticalAttractionCutoff)
+            if (BSParam.VehicleEnableAngularBanking && m_bankingEfficiency != 0 && m_verticalAttractionTimescale < m_verticalAttractionCutoff)
             {
                 Vector3 bankingContributionV = Vector3.Zero;
 
@@ -1498,10 +1654,10 @@ namespace OpenSim.Region.Physics.BulletSPlugin
 
                 //VehicleRotationalVelocity += bankingContributionV * VehicleOrientation;
                 VehicleRotationalVelocity += bankingContributionV;
-                
+
 
                 VDetailLog("{0},  MoveAngular,Banking,rollComp={1},speed={2},rollComp={3},yAng={4},mYAng={5},ret={6}",
-                            Prim.LocalID, rollComponents, VehicleForwardSpeed, rollComponents, yawAngle, mixedYawAngle, bankingContributionV);
+                            ControllingPrim.LocalID, rollComponents, VehicleForwardSpeed, rollComponents, yawAngle, mixedYawAngle, bankingContributionV);
             }
         }
 
@@ -1540,8 +1696,37 @@ namespace OpenSim.Region.Physics.BulletSPlugin
             if (rotq != m_rot)
             {
                 VehicleOrientation = m_rot;
-                VDetailLog("{0},  LimitRotation,done,orig={1},new={2}", Prim.LocalID, rotq, m_rot);
+                VDetailLog("{0},  LimitRotation,done,orig={1},new={2}", ControllingPrim.LocalID, rotq, m_rot);
+            }
+
+        }
+
+        // Given a friction vector (reduction in seconds) and a timestep, return the factor to reduce
+        //     some value by to apply this friction.
+        private Vector3 ComputeFrictionFactor(Vector3 friction, float pTimestep)
+        {
+            Vector3 frictionFactor = Vector3.Zero;
+            if (friction != BSMotor.InfiniteVector)
+            {
+                // frictionFactor = (Vector3.One / FrictionTimescale) * timeStep;
+                // Individual friction components can be 'infinite' so compute each separately.
+                frictionFactor.X = (friction.X == BSMotor.Infinite) ? 0f : (1f / friction.X);
+                frictionFactor.Y = (friction.Y == BSMotor.Infinite) ? 0f : (1f / friction.Y);
+                frictionFactor.Z = (friction.Z == BSMotor.Infinite) ? 0f : (1f / friction.Z);
+                frictionFactor *= pTimestep;
+            }
+            return frictionFactor;
+        }
+
+        private float SortedClampInRange(float clampa, float val, float clampb)
+        {
+            if (clampa > clampb)
+            {
+                float temp = clampa;
+                clampa = clampb;
+                clampb = temp;
             }
+           return ClampInRange(clampa, val, clampb);
 
         }
 
@@ -1554,8 +1739,8 @@ namespace OpenSim.Region.Physics.BulletSPlugin
         // Invoke the detailed logger and output something if it's enabled.
         private void VDetailLog(string msg, params Object[] args)
         {
-            if (Prim.PhysicsScene.VehicleLoggingEnabled)
-                Prim.PhysicsScene.DetailLog(msg, args);
+            if (ControllingPrim.PhysScene.VehicleLoggingEnabled)
+                ControllingPrim.PhysScene.DetailLog(msg, args);
         }
     }
 }
diff --git a/OpenSim/Region/Physics/BulletSPlugin/BSLinkset.cs b/OpenSim/Region/Physics/BulletSPlugin/BSLinkset.cs
index 4ece1eb..77f69a5 100755
--- a/OpenSim/Region/Physics/BulletSPlugin/BSLinkset.cs
+++ b/OpenSim/Region/Physics/BulletSPlugin/BSLinkset.cs
@@ -33,14 +33,6 @@ using OMV = OpenMetaverse;
 namespace OpenSim.Region.Physics.BulletSPlugin
 {
 
-// A BSPrim can get individual information about its linkedness attached
-//    to it through an instance of a subclass of LinksetInfo.
-// Each type of linkset will define the information needed for its type.
-public abstract class BSLinksetInfo
-{
-    public virtual void Clear() { }
-}
-
 public abstract class BSLinkset
 {
     // private static string LogHeader = "[BULLETSIM LINKSET]";
@@ -56,15 +48,15 @@ public abstract class BSLinkset
     {
         BSLinkset ret = null;
 
-        switch ((int)BSParam.LinksetImplementation)
+        switch (parent.LinksetType)
         {
-            case (int)LinksetImplementation.Constraint:
+            case LinksetImplementation.Constraint:
                 ret = new BSLinksetConstraints(physScene, parent);
                 break;
-            case (int)LinksetImplementation.Compound:
+            case LinksetImplementation.Compound:
                 ret = new BSLinksetCompound(physScene, parent);
                 break;
-            case (int)LinksetImplementation.Manual:
+            case LinksetImplementation.Manual:
                 // ret = new BSLinksetManual(physScene, parent);
                 break;
             default:
@@ -78,28 +70,37 @@ public abstract class BSLinkset
         return ret;
     }
 
+    public class BSLinkInfo
+    {
+        public BSPrimLinkable member;
+        public BSLinkInfo(BSPrimLinkable pMember)
+        {
+            member = pMember;
+        }
+        public virtual void ResetLink() { }
+        public virtual void SetLinkParameters(BSConstraint constrain) { }
+        // Returns 'true' if physical property updates from the child should be reported to the simulator
+        public virtual bool ShouldUpdateChildProperties() { return false; }
+    }
+
+    public LinksetImplementation LinksetImpl { get; protected set; }
+
     public BSPrimLinkable LinksetRoot { get; protected set; }
 
-    public BSScene PhysicsScene { get; private set; }
+    protected BSScene m_physicsScene { get; private set; }
 
     static int m_nextLinksetID = 1;
     public int LinksetID { get; private set; }
 
     // The children under the root in this linkset.
-    protected HashSet<BSPrimLinkable> m_children;
+    // protected HashSet<BSPrimLinkable> m_children;
+    protected Dictionary<BSPrimLinkable, BSLinkInfo> m_children;
 
     // We lock the diddling of linkset classes to prevent any badness.
     // This locks the modification of the instances of this class. Changes
     //    to the physical representation is done via the tainting mechenism.
     protected object m_linksetActivityLock = new Object();
 
-    // Some linksets have a preferred physical shape.
-    // Returns SHAPE_UNKNOWN if there is no preference. Causes the correct shape to be selected.
-    public virtual BSPhysicsShapeType PreferredPhysicalShape(BSPrimLinkable requestor)
-    {
-        return BSPhysicsShapeType.SHAPE_UNKNOWN;
-    }
-
     // We keep the prim's mass in the linkset structure since it could be dependent on other prims
     public float LinksetMass { get; protected set; }
 
@@ -122,9 +123,9 @@ public abstract class BSLinkset
         // We create LOTS of linksets.
         if (m_nextLinksetID <= 0)
             m_nextLinksetID = 1;
-        PhysicsScene = scene;
+        m_physicsScene = scene;
         LinksetRoot = parent;
-        m_children = new HashSet<BSPrimLinkable>();
+        m_children = new Dictionary<BSPrimLinkable, BSLinkInfo>();
         LinksetMass = parent.RawMass;
         Rebuilding = false;
 
@@ -151,7 +152,7 @@ public abstract class BSLinkset
     // Returns a new linkset for the child which is a linkset of one (just the
     //    orphened child).
     // Called at runtime.
-    public BSLinkset RemoveMeFromLinkset(BSPrimLinkable child)
+    public BSLinkset RemoveMeFromLinkset(BSPrimLinkable child, bool inTaintTime)
     {
         lock (m_linksetActivityLock)
         {
@@ -160,12 +161,12 @@ public abstract class BSLinkset
                 // Cannot remove the root from a linkset.
                 return this;
             }
-            RemoveChildFromLinkset(child);
+            RemoveChildFromLinkset(child, inTaintTime);
             LinksetMass = ComputeLinksetMass();
         }
 
         // The child is down to a linkset of just itself
-        return BSLinkset.Factory(PhysicsScene, child);
+        return BSLinkset.Factory(m_physicsScene, child);
     }
 
     // Return 'true' if the passed object is the root object of this linkset
@@ -185,17 +186,7 @@ public abstract class BSLinkset
         bool ret = false;
         lock (m_linksetActivityLock)
         {
-            ret = m_children.Contains(child);
-            /* Safer version but the above should work
-            foreach (BSPrimLinkable bp in m_children)
-            {
-                if (child.LocalID == bp.LocalID)
-                {
-                    ret = true;
-                    break;
-                }
-            }
-             */
+            ret = m_children.ContainsKey(child);
         }
         return ret;
     }
@@ -209,7 +200,35 @@ public abstract class BSLinkset
         lock (m_linksetActivityLock)
         {
             action(LinksetRoot);
-            foreach (BSPrimLinkable po in m_children)
+            foreach (BSPrimLinkable po in m_children.Keys)
+            {
+                if (action(po))
+                    break;
+            }
+        }
+        return ret;
+    }
+
+    public bool TryGetLinkInfo(BSPrimLinkable child, out BSLinkInfo foundInfo)
+    {
+        bool ret = false;
+        BSLinkInfo found = null;
+        lock (m_linksetActivityLock)
+        {
+            ret = m_children.TryGetValue(child, out found);
+        }
+        foundInfo = found;
+        return ret;
+    }
+    // Perform an action on each member of the linkset including root prim.
+    // Depends on the action on whether this should be done at taint time.
+    public delegate bool ForEachLinkInfoAction(BSLinkInfo obj);
+    public virtual bool ForEachLinkInfo(ForEachLinkInfoAction action)
+    {
+        bool ret = false;
+        lock (m_linksetActivityLock)
+        {
+            foreach (BSLinkInfo po in m_children.Values)
             {
                 if (action(po))
                     break;
@@ -218,13 +237,55 @@ public abstract class BSLinkset
         return ret;
     }
 
+    // Check the type of the link and return 'true' if the link is flexible and the
+    //    updates from the child should be sent to the simulator so things change.
+    public virtual bool ShouldReportPropertyUpdates(BSPrimLinkable child)
+    {
+        bool ret = false;
+
+        BSLinkInfo linkInfo;
+        if (m_children.TryGetValue(child, out linkInfo))
+        {
+            ret = linkInfo.ShouldUpdateChildProperties();
+        }
+
+        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);
-    
+
     // I am the root of a linkset and one of my children is being removed.
     // Safe to call even if the child is not really in my linkset.
-    protected abstract void RemoveChildFromLinkset(BSPrimLinkable child);
+    protected abstract void RemoveChildFromLinkset(BSPrimLinkable child, bool inTaintTime);
 
     // When physical properties are changed the linkset needs to recalculate
     //   its internal properties.
@@ -263,9 +324,88 @@ public abstract class BSLinkset
     // This is called when the root body is changing.
     // Returns 'true' of something was actually removed and would need restoring
     // Called at taint-time!!
-    public abstract bool RemoveBodyDependencies(BSPrimLinkable child);
+    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 ComputeAndSetLocalInertia(OMV.Vector3 inertiaFactor, float linksetMass)
+    {
+        ForEachMember((member) =>
+            {
+                if (member.PhysBody.HasPhysicalBody)
+                {
+                    OMV.Vector3 inertia = m_physicsScene.PE.CalculateLocalInertia(member.PhysShape.physShapeInfo, linksetMass);
+                    member.Inertia = inertia * inertiaFactor;
+                    m_physicsScene.PE.SetMassProps(member.PhysBody, linksetMass, member.Inertia);
+                    m_physicsScene.PE.UpdateInertiaTensor(member.PhysBody);
+                    DetailLog("{0},BSLinkset.ComputeAndSetLocalInertia,m.mass={1}, inertia={2}", member.LocalID, linksetMass, member.Inertia);
+
+                }
+                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 AddToPhysicalCollisionFlags(CollisionFlags collFlags)
+    {
+        ForEachMember((member) =>
+            {
+                if (member.PhysBody.HasPhysicalBody)
+                    m_physicsScene.PE.AddToCollisionFlags(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;
@@ -273,7 +413,7 @@ public abstract class BSLinkset
         {
             lock (m_linksetActivityLock)
             {
-                foreach (BSPrimLinkable bp in m_children)
+                foreach (BSPrimLinkable bp in m_children.Keys)
                 {
                     mass += bp.RawMass;
                 }
@@ -291,7 +431,7 @@ public abstract class BSLinkset
             com = LinksetRoot.Position * LinksetRoot.RawMass;
             float totalMass = LinksetRoot.RawMass;
 
-            foreach (BSPrimLinkable bp in m_children)
+            foreach (BSPrimLinkable bp in m_children.Keys)
             {
                 com += bp.Position * bp.RawMass;
                 totalMass += bp.RawMass;
@@ -310,7 +450,7 @@ public abstract class BSLinkset
         {
             com = LinksetRoot.Position;
 
-            foreach (BSPrimLinkable bp in m_children)
+            foreach (BSPrimLinkable bp in m_children.Keys)
             {
                 com += bp.Position;
             }
@@ -320,12 +460,18 @@ public abstract class BSLinkset
         return com;
     }
 
+    #region Extension
+    public virtual object Extension(string pFunct, params object[] pParams)
+    {
+        return null;
+    }
+    #endregion // Extension
+
     // Invoke the detailed logger and output something if it's enabled.
     protected void DetailLog(string msg, params Object[] args)
     {
-        if (PhysicsScene.PhysicsLogging.Enabled)
-            PhysicsScene.DetailLog(msg, args);
+        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 e05562a..8f12189 100755
--- a/OpenSim/Region/Physics/BulletSPlugin/BSLinksetCompound.cs
+++ b/OpenSim/Region/Physics/BulletSPlugin/BSLinksetCompound.cs
@@ -35,103 +35,78 @@ using OMV = OpenMetaverse;
 namespace OpenSim.Region.Physics.BulletSPlugin
 {
 
-// When a child is linked, the relationship position of the child to the parent
-//    is remembered so the child's world position can be recomputed when it is
-//    removed from the linkset.
-sealed class BSLinksetCompoundInfo : BSLinksetInfo
+public sealed class BSLinksetCompound : BSLinkset
 {
-    public int Index;
-    public OMV.Vector3 OffsetFromRoot;
-    public OMV.Vector3 OffsetFromCenterOfMass;
-    public OMV.Quaternion OffsetRot;
-    public BSLinksetCompoundInfo(int indx, OMV.Vector3 p, OMV.Quaternion r)
+    private static string LogHeader = "[BULLETSIM LINKSET COMPOUND]";
+
+    public BSLinksetCompound(BSScene scene, BSPrimLinkable parent)
+        : base(scene, parent)
     {
-        Index = indx;
-        OffsetFromRoot = p;
-        OffsetFromCenterOfMass = p;
-        OffsetRot = r;
+        LinksetImpl = LinksetImplementation.Compound;
     }
-    // 'centerDisplacement' is the distance from the root the the center-of-mass (Bullet 'zero' of the shape)
-    public BSLinksetCompoundInfo(int indx, BSPrimLinkable root, BSPrimLinkable child, OMV.Vector3 centerDisplacement)
+
+    // ================================================================
+    // Changing the physical property of the linkset only needs to change the root
+    public override void SetPhysicalFriction(float friction)
     {
-        // Each child position and rotation is given relative to the center-of-mass.
-        OMV.Quaternion invRootOrientation = OMV.Quaternion.Inverse(root.RawOrientation);
-        OMV.Vector3 displacementFromRoot = (child.RawPosition - root.RawPosition) * invRootOrientation;
-        OMV.Vector3 displacementFromCOM = displacementFromRoot - centerDisplacement;
-        OMV.Quaternion displacementRot = child.RawOrientation * invRootOrientation;
-
-        // Save relative position for recomputing child's world position after moving linkset.
-        Index = indx;
-        OffsetFromRoot = displacementFromRoot;
-        OffsetFromCenterOfMass = displacementFromCOM;
-        OffsetRot = displacementRot;
+        if (LinksetRoot.PhysBody.HasPhysicalBody)
+            m_physicsScene.PE.SetFriction(LinksetRoot.PhysBody, friction);
     }
-    public override void Clear()
+    public override void SetPhysicalRestitution(float restitution)
     {
-        Index = 0;
-        OffsetFromRoot = OMV.Vector3.Zero;
-        OffsetFromCenterOfMass = OMV.Vector3.Zero;
-        OffsetRot = OMV.Quaternion.Identity;
+        if (LinksetRoot.PhysBody.HasPhysicalBody)
+            m_physicsScene.PE.SetRestitution(LinksetRoot.PhysBody, restitution);
     }
-    public override string ToString()
+    public override void SetPhysicalGravity(OMV.Vector3 gravity)
     {
-        StringBuilder buff = new StringBuilder();
-        buff.Append("<i=");
-        buff.Append(Index.ToString());
-        buff.Append(",p=");
-        buff.Append(OffsetFromRoot.ToString());
-        buff.Append(",m=");
-        buff.Append(OffsetFromCenterOfMass.ToString());
-        buff.Append(",r=");
-        buff.Append(OffsetRot.ToString());
-        buff.Append(">");
-        return buff.ToString();
+        if (LinksetRoot.PhysBody.HasPhysicalBody)
+            m_physicsScene.PE.SetGravity(LinksetRoot.PhysBody, gravity);
     }
-};
-
-public sealed class BSLinksetCompound : BSLinkset
-{
-    private static string LogHeader = "[BULLETSIM LINKSET COMPOUND]";
-
-    public BSLinksetCompound(BSScene scene, BSPrimLinkable parent)
-        : base(scene, parent)
+    public override void ComputeAndSetLocalInertia(OMV.Vector3 inertiaFactor, float linksetMass)
     {
+        OMV.Vector3 inertia = m_physicsScene.PE.CalculateLocalInertia(LinksetRoot.PhysShape.physShapeInfo, linksetMass);
+        LinksetRoot.Inertia = inertia * inertiaFactor;
+        m_physicsScene.PE.SetMassProps(LinksetRoot.PhysBody, linksetMass, LinksetRoot.Inertia);
+        m_physicsScene.PE.UpdateInertiaTensor(LinksetRoot.PhysBody);
     }
-
-    // For compound implimented linksets, if there are children, use compound shape for the root.
-    public override BSPhysicsShapeType PreferredPhysicalShape(BSPrimLinkable requestor)
-    { 
-        // Returning 'unknown' means we don't have a preference.
-        BSPhysicsShapeType ret = BSPhysicsShapeType.SHAPE_UNKNOWN;
-        if (IsRoot(requestor) && HasAnyChildren)
-        {
-            ret = BSPhysicsShapeType.SHAPE_COMPOUND;
-        }
-        // DetailLog("{0},BSLinksetCompound.PreferredPhysicalShape,call,shape={1}", LinksetRoot.LocalID, ret);
-        return ret;
+    public override void SetPhysicalCollisionFlags(CollisionFlags collFlags)
+    {
+        if (LinksetRoot.PhysBody.HasPhysicalBody)
+            m_physicsScene.PE.SetCollisionFlags(LinksetRoot.PhysBody, collFlags);
+    }
+    public override void AddToPhysicalCollisionFlags(CollisionFlags collFlags)
+    {
+        if (LinksetRoot.PhysBody.HasPhysicalBody)
+            m_physicsScene.PE.AddToCollisionFlags(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)
     {
-        base.Refresh(requestor);
-
         // Something changed so do the rebuilding thing
-        // ScheduleRebuild();
+        ScheduleRebuild(requestor);
+        base.Refresh(requestor);
     }
 
     // Schedule a refresh to happen after all the other taint processing.
     private void ScheduleRebuild(BSPrimLinkable requestor)
     {
-        DetailLog("{0},BSLinksetCompound.ScheduleRebuild,,rebuilding={1},hasChildren={2},actuallyScheduling={3}", 
+        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.
         if (!Rebuilding && HasAnyChildren)
         {
-            PhysicsScene.PostTaintObject("BSLinksetCompound.ScheduleRebuild", LinksetRoot.LocalID, delegate()
+            m_physicsScene.PostTaintObject("BSLinksetCompound.ScheduleRebuild", LinksetRoot.LocalID, delegate()
             {
                 if (HasAnyChildren)
                     RecomputeLinksetCompound();
@@ -151,47 +126,24 @@ public sealed class BSLinksetCompound : BSLinkset
         if (IsRoot(child))
         {
             // The root is going dynamic. Rebuild the linkset so parts and mass get computed properly.
-            ScheduleRebuild(LinksetRoot);
-        }
-        else
-        {
-            // The origional prims are removed from the world as the shape of the root compound
-            //     shape takes over.
-            PhysicsScene.PE.AddToCollisionFlags(child.PhysBody, CollisionFlags.CF_NO_CONTACT_RESPONSE);
-            PhysicsScene.PE.ForceActivationState(child.PhysBody, ActivationState.DISABLE_SIMULATION);
-            // We don't want collisions from the old linkset children.
-            PhysicsScene.PE.RemoveFromCollisionFlags(child.PhysBody, CollisionFlags.BS_SUBSCRIBE_COLLISION_EVENTS);
-
-            child.PhysBody.collisionType = CollisionType.LinksetChild;
-
-            ret = true;
+            Refresh(LinksetRoot);
         }
         return ret;
     }
 
-    // The object is going static (non-physical). Do any setup necessary for a static linkset.
+    // The object is going static (non-physical). We do not do anything for static linksets.
     // Return 'true' if any properties updated on the passed object.
-    // This doesn't normally happen -- OpenSim removes the objects from the physical
-    //     world if it is a static linkset.
     // Called at taint-time!
     public override bool MakeStatic(BSPrimLinkable child)
     {
         bool ret = false;
+
         DetailLog("{0},BSLinksetCompound.MakeStatic,call,IsRoot={1}", child.LocalID, IsRoot(child));
+        child.ClearDisplacement();
         if (IsRoot(child))
         {
-            ScheduleRebuild(LinksetRoot);
-        }
-        else
-        {
-            // The non-physical children can come back to life.
-            PhysicsScene.PE.RemoveFromCollisionFlags(child.PhysBody, CollisionFlags.CF_NO_CONTACT_RESPONSE);
-
-            child.PhysBody.collisionType = CollisionType.LinksetChild;
-
-            // Don't force activation so setting of DISABLE_SIMULATION can stay if used.
-            PhysicsScene.PE.Activate(child.PhysBody, false);
-            ret = true;
+            // Schedule a rebuild to verify that the root shape is set to the real shape.
+            Refresh(LinksetRoot);
         }
         return ret;
     }
@@ -200,13 +152,20 @@ public sealed class BSLinksetCompound : BSLinkset
     // Called at taint-time.
     public override void UpdateProperties(UpdatedProperties whichUpdated, BSPrimLinkable updated)
     {
+        if (!LinksetRoot.IsPhysicallyActive)
+        {
+            // No reason to do this physical stuff for static linksets.
+            DetailLog("{0},BSLinksetCompound.UpdateProperties,notPhysical", LinksetRoot.LocalID);
+            return;
+        }
+
         // The user moving a child around requires the rebuilding of the linkset compound shape
         // One problem is this happens when a border is crossed -- the simulator implementation
         //    stores the position into the group which causes the move of the object
         //    but it also means all the child positions get updated.
         //    What would cause an unnecessary rebuild so we make sure the linkset is in a
         //    region before bothering to do a rebuild.
-        if (!IsRoot(updated) && PhysicsScene.TerrainManager.IsWithinKnownTerrain(LinksetRoot.RawPosition))
+        if (!IsRoot(updated) && m_physicsScene.TerrainManager.IsWithinKnownTerrain(LinksetRoot.RawPosition))
         {
             // If a child of the linkset is updating only the position or rotation, that can be done
             //    without rebuilding the linkset.
@@ -218,22 +177,22 @@ public sealed class BSLinksetCompound : BSLinkset
             //     and that is caused by us updating the object.
             if ((whichUpdated & ~(UpdatedProperties.Position | UpdatedProperties.Orientation)) == 0)
             {
-                    // Find the physical instance of the child 
-                if (LinksetRoot.PhysShape.HasPhysicalShape && PhysicsScene.PE.IsCompound(LinksetRoot.PhysShape))
+                // Find the physical instance of the child
+                if (LinksetRoot.PhysShape.HasPhysicalShape && m_physicsScene.PE.IsCompound(LinksetRoot.PhysShape.physShapeInfo))
                 {
                     // It is possible that the linkset is still under construction and the child is not yet
                     //    inserted into the compound shape. A rebuild of the linkset in a pre-step action will
                     //    build the whole thing with the new position or rotation.
                     // The index must be checked because Bullet references the child array but does no validity
                     //    checking of the child index passed.
-                    int numLinksetChildren = PhysicsScene.PE.GetNumberOfCompoundChildren(LinksetRoot.PhysShape);
+                    int numLinksetChildren = m_physicsScene.PE.GetNumberOfCompoundChildren(LinksetRoot.PhysShape.physShapeInfo);
                     if (updated.LinksetChildIndex < numLinksetChildren)
                     {
-                        BulletShape linksetChildShape = PhysicsScene.PE.GetChildShapeFromCompoundShapeIndex(LinksetRoot.PhysShape, updated.LinksetChildIndex);
+                        BulletShape linksetChildShape = m_physicsScene.PE.GetChildShapeFromCompoundShapeIndex(LinksetRoot.PhysShape.physShapeInfo, updated.LinksetChildIndex);
                         if (linksetChildShape.HasPhysicalShape)
                         {
                             // Found the child shape within the compound shape
-                            PhysicsScene.PE.UpdateChildTransform(LinksetRoot.PhysShape, updated.LinksetChildIndex,
+                            m_physicsScene.PE.UpdateChildTransform(LinksetRoot.PhysShape.physShapeInfo, updated.LinksetChildIndex,
                                                                         updated.RawPosition - LinksetRoot.RawPosition,
                                                                         updated.RawOrientation * OMV.Quaternion.Inverse(LinksetRoot.RawOrientation),
                                                                         true /* shouldRecalculateLocalAabb */);
@@ -267,83 +226,29 @@ public sealed class BSLinksetCompound : BSLinkset
                     //    there will already be a rebuild scheduled.
                     DetailLog("{0},BSLinksetCompound.UpdateProperties,couldNotUpdateChild.schedulingRebuild,whichUpdated={1}",
                                                                     updated.LocalID, whichUpdated);
-                    updated.LinksetInfo = null; // setting to 'null' causes relative position to be recomputed.
-                    ScheduleRebuild(updated);
+                    Refresh(updated);
                 }
             }
         }
     }
 
     // Routine called when rebuilding the body of some member of the linkset.
-    // Since we don't keep in world relationships, do nothing unless it's a child changing.
+    // If one of the bodies is being changed, the linkset needs rebuilding.
+    // For instance, a linkset is built and then a mesh asset is read in and the mesh is recreated.
     // Returns 'true' of something was actually removed and would need restoring
     // Called at taint-time!!
-    public override bool RemoveBodyDependencies(BSPrimLinkable child)
+    public override bool RemoveDependencies(BSPrimLinkable child)
     {
         bool ret = false;
 
-        DetailLog("{0},BSLinksetCompound.RemoveBodyDependencies,refreshIfChild,rID={1},rBody={2},isRoot={3}",
+        DetailLog("{0},BSLinksetCompound.RemoveDependencies,refreshIfChild,rID={1},rBody={2},isRoot={3}",
                         child.LocalID, LinksetRoot.LocalID, LinksetRoot.PhysBody, IsRoot(child));
 
-        if (!IsRoot(child))
-        {
-            // Because it is a convenient time, recompute child world position and rotation based on
-            //    its position in the linkset.
-            RecomputeChildWorldPosition(child, true /* inTaintTime */);
-            child.LinksetInfo = null;
-        }
-
-        // Cannot schedule a refresh/rebuild here because this routine is called when
-        //     the linkset is being rebuilt.
-        // InternalRefresh(LinksetRoot);
+        Refresh(child);
 
         return ret;
     }
 
-    // When the linkset is built, the child shape is added to the compound shape relative to the
-    //    root shape. The linkset then moves around but this does not move the actual child
-    //    prim. The child prim's location must be recomputed based on the location of the root shape.
-    private void RecomputeChildWorldPosition(BSPrimLinkable child, bool inTaintTime)
-    {
-        // For the moment (20130201), disable this computation (converting the child physical addr back to
-        //    a region address) until we have a good handle on center-of-mass offsets and what the physics
-        //    engine moving a child actually means.
-        // The simulator keeps track of where children should be as the linkset moves. Setting
-        //    the pos/rot here does not effect that knowledge as there is no good way for the
-        //    physics engine to send the simulator an update for a child.
-
-        /*
-        BSLinksetCompoundInfo lci = child.LinksetInfo as BSLinksetCompoundInfo;
-        if (lci != null)
-        {
-            if (inTaintTime)
-            {
-                OMV.Vector3 oldPos = child.RawPosition;
-                child.ForcePosition = LinksetRoot.RawPosition + lci.OffsetFromRoot;
-                child.ForceOrientation = LinksetRoot.RawOrientation * lci.OffsetRot;
-                DetailLog("{0},BSLinksetCompound.RecomputeChildWorldPosition,oldPos={1},lci={2},newPos={3}",
-                                            child.LocalID, oldPos, lci, child.RawPosition);
-            }
-            else
-            {
-                // TaintedObject is not used here so the raw position is set now and not at taint-time.
-                child.Position = LinksetRoot.RawPosition + lci.OffsetFromRoot;
-                child.Orientation = LinksetRoot.RawOrientation * lci.OffsetRot;
-            }
-        }
-        else
-        {
-            // This happens when children have been added to the linkset but the linkset
-            //     has not been constructed yet. So like, at taint time, adding children to a linkset
-            //     and then changing properties of the children (makePhysical, for instance)
-            //     but the post-print action of actually rebuilding the linkset has not yet happened.
-            // PhysicsScene.Logger.WarnFormat("{0} Restoring linkset child position failed because of no relative position computed. ID={1}",
-            //                                 LogHeader, child.LocalID);
-            DetailLog("{0},BSLinksetCompound.recomputeChildWorldPosition,noRelativePositonInfo", child.LocalID);
-        }
-        */
-    }
-
     // ================================================================
 
     // Add a new child to the linkset.
@@ -352,19 +257,19 @@ public sealed class BSLinksetCompound : BSLinkset
     {
         if (!HasChild(child))
         {
-            m_children.Add(child);
+            m_children.Add(child, new BSLinkInfo(child));
 
             DetailLog("{0},BSLinksetCompound.AddChildToLinkset,call,child={1}", LinksetRoot.LocalID, child.LocalID);
 
             // Rebuild the compound shape with the new child shape included
-            ScheduleRebuild(child);
+            Refresh(child);
         }
         return;
     }
 
     // Remove the specified child from the linkset.
     // Safe to call even if the child is not really in the linkset.
-    protected override void RemoveChildFromLinkset(BSPrimLinkable child)
+    protected override void RemoveChildFromLinkset(BSPrimLinkable child, bool inTaintTime)
     {
         child.ClearDisplacement();
 
@@ -376,19 +281,17 @@ public sealed class BSLinksetCompound : BSLinkset
                             child.LocalID, child.PhysBody.AddrString);
 
             // Cause the child's body to be rebuilt and thus restored to normal operation
-            RecomputeChildWorldPosition(child, false);
-            child.LinksetInfo = null;
-            child.ForceBodyShapeRebuild(false);
+            child.ForceBodyShapeRebuild(inTaintTime);
 
             if (!HasAnyChildren)
             {
                 // The linkset is now empty. The root needs rebuilding.
-                LinksetRoot.ForceBodyShapeRebuild(false);
+                LinksetRoot.ForceBodyShapeRebuild(inTaintTime);
             }
             else
             {
                 // Rebuild the compound shape with the child removed
-                ScheduleRebuild(LinksetRoot);
+                Refresh(LinksetRoot);
             }
         }
         return;
@@ -399,108 +302,118 @@ public sealed class BSLinksetCompound : BSLinkset
     // Constraint linksets are rebuilt every time.
     // Note that this works for rebuilding just the root after a linkset is taken apart.
     // Called at taint time!!
-    private bool disableCOM = true;     // DEBUG DEBUG: disable until we get this debugged
+    private bool UseBulletSimRootOffsetHack = false;    // Attempt to have Bullet track the coords of root compound shape
     private void RecomputeLinksetCompound()
     {
         try
         {
-            // Suppress rebuilding while rebuilding. (We know rebuilding is on only one thread.)
             Rebuilding = true;
 
-            // Cause the root shape to be rebuilt as a compound object with just the root in it
-            LinksetRoot.ForceBodyShapeRebuild(true /* inTaintTime */);
+            // No matter what is being done, force the root prim's PhysBody and PhysShape to get set
+            //     to what they should be as if the root was not in a linkset.
+            // Not that bad since we only get into this routine if there are children in the linkset and
+            //     something has been updated/changed.
+            // Have to do the rebuild before checking for physical because this might be a linkset
+            //     being destructed and going non-physical.
+            LinksetRoot.ForceBodyShapeRebuild(true);
 
-            // The center of mass for the linkset is the geometric center of the group.
-            // Compute a displacement for each component so it is relative to the center-of-mass.
-            // Bullet presumes an object's origin (relative <0,0,0>) is its center-of-mass
-            OMV.Vector3 centerOfMassW = LinksetRoot.RawPosition;
-            if (!disableCOM)                             // DEBUG DEBUG
+            // There is no reason to build all this physical stuff for a non-physical or empty linkset.
+            if (!LinksetRoot.IsPhysicallyActive || !HasAnyChildren)
             {
-                // Compute a center-of-mass in world coordinates.
-                centerOfMassW = ComputeLinksetCenterOfMass();
+                DetailLog("{0},BSLinksetCompound.RecomputeLinksetCompound,notPhysicalOrNoChildren", LinksetRoot.LocalID);
+                return; // Note the 'finally' clause at the botton which will get executed.
             }
 
-            OMV.Quaternion invRootOrientation = OMV.Quaternion.Inverse(LinksetRoot.RawOrientation);
-
-            // 'centerDisplacement' is the value to subtract from children to give physical offset position
-            OMV.Vector3 centerDisplacement = (centerOfMassW - LinksetRoot.RawPosition) * invRootOrientation;
-            LinksetRoot.SetEffectiveCenterOfMassW(centerDisplacement);
+            // Get a new compound shape to build the linkset shape in.
+            BSShape linksetShape = BSShapeCompound.GetReference(m_physicsScene);
 
-            // This causes the physical position of the root prim to be offset to accomodate for the displacements
-            LinksetRoot.ForcePosition = LinksetRoot.RawPosition;
+            // Compute a displacement for each component so it is relative to the center-of-mass.
+            // Bullet presumes an object's origin (relative <0,0,0>) is its center-of-mass
+            OMV.Vector3 centerOfMassW = ComputeLinksetCenterOfMass();
 
-            // Update the local transform for the root child shape so it is offset from the <0,0,0> which is COM
-            PhysicsScene.PE.UpdateChildTransform(LinksetRoot.PhysShape, 0 /* childIndex */,
-                                                -centerDisplacement,
-                                                OMV.Quaternion.Identity, // LinksetRoot.RawOrientation,
-                                                false /* shouldRecalculateLocalAabb (is done later after linkset built) */);
+            OMV.Quaternion invRootOrientation = OMV.Quaternion.Normalize(OMV.Quaternion.Inverse(LinksetRoot.RawOrientation));
+            OMV.Vector3 origRootPosition = LinksetRoot.RawPosition;
 
-            DetailLog("{0},BSLinksetCompound.RecomputeLinksetCompound,COM,com={1},rootPos={2},centerDisp={3}",
-                                    LinksetRoot.LocalID, centerOfMassW, LinksetRoot.RawPosition, centerDisplacement);
+            // 'centerDisplacementV' is the vehicle relative distance from the simulator root position to the center-of-mass
+            OMV.Vector3 centerDisplacementV = (centerOfMassW - LinksetRoot.RawPosition) * invRootOrientation;
+            if (UseBulletSimRootOffsetHack || !BSParam.LinksetOffsetCenterOfMass)
+            {
+                // Zero everything if center-of-mass displacement is not being done.
+                centerDisplacementV = OMV.Vector3.Zero;
+                LinksetRoot.ClearDisplacement();
+            }
+            else
+            {
+                // The actual center-of-mass could have been set by the user.
+                centerDisplacementV = LinksetRoot.SetEffectiveCenterOfMassDisplacement(centerDisplacementV);
+            }
 
-            DetailLog("{0},BSLinksetCompound.RecomputeLinksetCompound,start,rBody={1},rShape={2},numChildren={3}",
-                            LinksetRoot.LocalID, LinksetRoot.PhysBody, LinksetRoot.PhysShape, NumberOfChildren);
+            DetailLog("{0},BSLinksetCompound.RecomputeLinksetCompound,COM,rootPos={1},com={2},comDisp={3}",
+                                LinksetRoot.LocalID, origRootPosition, centerOfMassW, centerDisplacementV);
 
-            // Add a shape for each of the other children in the linkset
+            // Add the shapes of all the components of the linkset
             int memberIndex = 1;
-            ForEachMember(delegate(BSPrimLinkable cPrim)
+            ForEachMember((cPrim) =>
             {
                 if (IsRoot(cPrim))
                 {
+                    // Root shape is always index zero.
                     cPrim.LinksetChildIndex = 0;
                 }
                 else
                 {
                     cPrim.LinksetChildIndex = memberIndex;
+                    memberIndex++;
+                }
 
-                    if (cPrim.PhysShape.isNativeShape)
-                    {
-                        // A native shape is turned into a hull collision shape because native
-                        //    shapes are not shared so we have to hullify it so it will be tracked
-                        //    and freed at the correct time. This also solves the scaling problem
-                        //    (native shapes scale but hull/meshes are assumed to not be).
-                        // TODO: decide of the native shape can just be used in the compound shape.
-                        //    Use call to CreateGeomNonSpecial().
-                        BulletShape saveShape = cPrim.PhysShape;
-                        cPrim.PhysShape.Clear();        // Don't let the create free the child's shape
-                        PhysicsScene.Shapes.CreateGeomMeshOrHull(cPrim, null);
-                        BulletShape newShape = cPrim.PhysShape;
-                        cPrim.PhysShape = saveShape;
-
-                        OMV.Vector3 offsetPos = (cPrim.RawPosition - LinksetRoot.RawPosition) * invRootOrientation - centerDisplacement;
-                        OMV.Quaternion offsetRot = cPrim.RawOrientation * invRootOrientation;
-                        PhysicsScene.PE.AddChildShapeToCompoundShape(LinksetRoot.PhysShape, newShape, offsetPos, offsetRot);
-                        DetailLog("{0},BSLinksetCompound.RecomputeLinksetCompound,addNative,indx={1},rShape={2},cShape={3},offPos={4},offRot={5}",
-                                    LinksetRoot.LocalID, memberIndex, LinksetRoot.PhysShape, newShape, offsetPos, offsetRot);
-                    }
-                    else
-                    {
-                        // For the shared shapes (meshes and hulls), just use the shape in the child.
-                        // The reference count added here will be decremented when the compound shape
-                        //     is destroyed in BSShapeCollection (the child shapes are looped over and dereferenced).
-                        if (PhysicsScene.Shapes.ReferenceShape(cPrim.PhysShape))
-                        {
-                            PhysicsScene.Logger.ErrorFormat("{0} Rebuilt sharable shape when building linkset! Region={1}, primID={2}, shape={3}",
-                                                LogHeader, PhysicsScene.RegionName, cPrim.LocalID, cPrim.PhysShape);
-                        }
-                        OMV.Vector3 offsetPos = (cPrim.RawPosition - LinksetRoot.RawPosition) * invRootOrientation - centerDisplacement;
-                        OMV.Quaternion offsetRot = cPrim.RawOrientation * invRootOrientation;
-                        PhysicsScene.PE.AddChildShapeToCompoundShape(LinksetRoot.PhysShape, cPrim.PhysShape, offsetPos, offsetRot);
-                        DetailLog("{0},BSLinksetCompound.RecomputeLinksetCompound,addNonNative,indx={1},rShape={2},cShape={3},offPos={4},offRot={5}",
-                                    LinksetRoot.LocalID, memberIndex, LinksetRoot.PhysShape, cPrim.PhysShape, offsetPos, offsetRot);
+                // Get a reference to the shape of the child for adding of that shape to the linkset compound shape
+                BSShape childShape = cPrim.PhysShape.GetReference(m_physicsScene, cPrim);
 
-                    }
-                    memberIndex++;
+                // Offset the child shape from the center-of-mass and rotate it to vehicle relative.
+                OMV.Vector3 offsetPos = (cPrim.RawPosition - origRootPosition) * invRootOrientation - centerDisplacementV;
+                OMV.Quaternion offsetRot = OMV.Quaternion.Normalize(cPrim.RawOrientation) * invRootOrientation;
+
+                // Add the child shape to the compound shape being built
+                m_physicsScene.PE.AddChildShapeToCompoundShape(linksetShape.physShapeInfo, childShape.physShapeInfo, offsetPos, offsetRot);
+                DetailLog("{0},BSLinksetCompound.RecomputeLinksetCompound,addChild,indx={1},cShape={2},offPos={3},offRot={4}",
+                                    LinksetRoot.LocalID, cPrim.LinksetChildIndex, childShape, offsetPos, offsetRot);
+
+                // Since we are borrowing the shape of the child, disable the origional child body
+                if (!IsRoot(cPrim))
+                {
+                    m_physicsScene.PE.AddToCollisionFlags(cPrim.PhysBody, CollisionFlags.CF_NO_CONTACT_RESPONSE);
+                    m_physicsScene.PE.ForceActivationState(cPrim.PhysBody, ActivationState.DISABLE_SIMULATION);
+                    // We don't want collisions from the old linkset children.
+                    m_physicsScene.PE.RemoveFromCollisionFlags(cPrim.PhysBody, CollisionFlags.BS_SUBSCRIBE_COLLISION_EVENTS);
+                    cPrim.PhysBody.collisionType = CollisionType.LinksetChild;
                 }
+
                 return false;   // 'false' says to move onto the next child in the list
             });
 
+            // Replace the root shape with the built compound shape.
+            // Object removed and added to world to get collision cache rebuilt for new shape.
+            LinksetRoot.PhysShape.Dereference(m_physicsScene);
+            LinksetRoot.PhysShape = linksetShape;
+            m_physicsScene.PE.RemoveObjectFromWorld(m_physicsScene.World, LinksetRoot.PhysBody);
+            m_physicsScene.PE.SetCollisionShape(m_physicsScene.World, LinksetRoot.PhysBody, linksetShape.physShapeInfo);
+            m_physicsScene.PE.AddObjectToWorld(m_physicsScene.World, LinksetRoot.PhysBody);
+            DetailLog("{0},BSLinksetCompound.RecomputeLinksetCompound,addBody,body={1},shape={2}",
+                                        LinksetRoot.LocalID, LinksetRoot.PhysBody, linksetShape);
+
             // With all of the linkset packed into the root prim, it has the mass of everyone.
             LinksetMass = ComputeLinksetMass();
             LinksetRoot.UpdatePhysicalMassProperties(LinksetMass, true);
 
-            // Enable the physical position updator to return the position and rotation of the root shape
-            PhysicsScene.PE.AddToCollisionFlags(LinksetRoot.PhysBody, CollisionFlags.BS_RETURN_ROOT_COMPOUND_SHAPE);
+            if (UseBulletSimRootOffsetHack)
+            {
+                // Enable the physical position updator to return the position and rotation of the root shape.
+                // This enables a feature in the C++ code to return the world coordinates of the first shape in the
+                //     compound shape. This aleviates the need to offset the returned physical position by the
+                //     center-of-mass offset.
+                // TODO: either debug this feature or remove it.
+                m_physicsScene.PE.AddToCollisionFlags(LinksetRoot.PhysBody, CollisionFlags.BS_RETURN_ROOT_COMPOUND_SHAPE);
+            }
         }
         finally
         {
@@ -508,7 +421,7 @@ public sealed class BSLinksetCompound : BSLinkset
         }
 
         // See that the Aabb surrounds the new shape
-        PhysicsScene.PE.RecalculateCompoundShapeLocalAabb(LinksetRoot.PhysShape);
+        m_physicsScene.PE.RecalculateCompoundShapeLocalAabb(LinksetRoot.PhysShape.physShapeInfo);
     }
 }
 }
\ No newline at end of file
diff --git a/OpenSim/Region/Physics/BulletSPlugin/BSLinksetConstraints.cs b/OpenSim/Region/Physics/BulletSPlugin/BSLinksetConstraints.cs
index 6d252ca..aaf92c8 100755
--- a/OpenSim/Region/Physics/BulletSPlugin/BSLinksetConstraints.cs
+++ b/OpenSim/Region/Physics/BulletSPlugin/BSLinksetConstraints.cs
@@ -1,4 +1,4 @@
-/*
+/*
  * Copyright (c) Contributors, http://opensimulator.org/
  * See CONTRIBUTORS.TXT for a full list of copyright holders.
  *
@@ -28,6 +28,8 @@ using System;
 using System.Collections.Generic;
 using System.Text;
 
+using OpenSim.Region.OptionalModules.Scripting;
+
 using OMV = OpenMetaverse;
 
 namespace OpenSim.Region.Physics.BulletSPlugin
@@ -36,26 +38,194 @@ public sealed class BSLinksetConstraints : BSLinkset
 {
     // private static string LogHeader = "[BULLETSIM LINKSET CONSTRAINTS]";
 
+    public class BSLinkInfoConstraint : BSLinkInfo
+    {
+        public ConstraintType constraintType;
+        public BSConstraint constraint;
+        public OMV.Vector3 linearLimitLow;
+        public OMV.Vector3 linearLimitHigh;
+        public OMV.Vector3 angularLimitLow;
+        public OMV.Vector3 angularLimitHigh;
+        public bool useFrameOffset;
+        public bool enableTransMotor;
+        public float transMotorMaxVel;
+        public float transMotorMaxForce;
+        public float cfm;
+        public float erp;
+        public float solverIterations;
+        //
+        public OMV.Vector3 frameInAloc;
+        public OMV.Quaternion frameInArot;
+        public OMV.Vector3 frameInBloc;
+        public OMV.Quaternion frameInBrot;
+        public bool useLinearReferenceFrameA;
+        // Spring
+        public bool[] springAxisEnable;
+        public float[] springDamping;
+        public float[] springStiffness;
+        public OMV.Vector3 springLinearEquilibriumPoint;
+        public OMV.Vector3 springAngularEquilibriumPoint;
+
+        public BSLinkInfoConstraint(BSPrimLinkable pMember)
+            : base(pMember)
+        {
+            constraint = null;
+            ResetLink();
+            member.PhysScene.DetailLog("{0},BSLinkInfoConstraint.creation", member.LocalID);
+        }
+
+        // Set all the parameters for this constraint to a fixed, non-movable constraint.
+        public override void ResetLink()
+        {
+            // constraintType = ConstraintType.D6_CONSTRAINT_TYPE;
+            constraintType = ConstraintType.FIXED_CONSTRAINT_TYPE;
+            linearLimitLow = OMV.Vector3.Zero;
+            linearLimitHigh = OMV.Vector3.Zero;
+            angularLimitLow = OMV.Vector3.Zero;
+            angularLimitHigh = OMV.Vector3.Zero;
+            useFrameOffset = BSParam.LinkConstraintUseFrameOffset;
+            enableTransMotor = BSParam.LinkConstraintEnableTransMotor;
+            transMotorMaxVel = BSParam.LinkConstraintTransMotorMaxVel;
+            transMotorMaxForce = BSParam.LinkConstraintTransMotorMaxForce;
+            cfm = BSParam.LinkConstraintCFM;
+            erp = BSParam.LinkConstraintERP;
+            solverIterations = BSParam.LinkConstraintSolverIterations;
+            frameInAloc = OMV.Vector3.Zero;
+            frameInArot = OMV.Quaternion.Identity;
+            frameInBloc = OMV.Vector3.Zero;
+            frameInBrot = OMV.Quaternion.Identity;
+            useLinearReferenceFrameA = true;
+            springAxisEnable = new bool[6];
+            springDamping = new float[6];
+            springStiffness = new float[6];
+            for (int ii = 0; ii < springAxisEnable.Length; ii++)
+            {
+                springAxisEnable[ii] = false;
+                springDamping[ii] = BSAPITemplate.SPRING_NOT_SPECIFIED;
+                springStiffness[ii] = BSAPITemplate.SPRING_NOT_SPECIFIED;
+            }
+            springLinearEquilibriumPoint = OMV.Vector3.Zero;
+            springAngularEquilibriumPoint = OMV.Vector3.Zero;
+            member.PhysScene.DetailLog("{0},BSLinkInfoConstraint.ResetLink", member.LocalID);
+        }
+
+        // Given a constraint, apply the current constraint parameters to same.
+        public override void SetLinkParameters(BSConstraint constrain)
+        {
+            member.PhysScene.DetailLog("{0},BSLinkInfoConstraint.SetLinkParameters,type={1}", member.LocalID, constraintType);
+            switch (constraintType)
+            {
+                case ConstraintType.FIXED_CONSTRAINT_TYPE:
+                case ConstraintType.D6_CONSTRAINT_TYPE:
+                    BSConstraint6Dof constrain6dof = constrain as BSConstraint6Dof;
+                    if (constrain6dof != null)
+                    {
+                        // NOTE: D6_SPRING_CONSTRAINT_TYPE should be updated if you change any of this code.
+                        // zero linear and angular limits makes the objects unable to move in relation to each other
+                        constrain6dof.SetLinearLimits(linearLimitLow, linearLimitHigh);
+                        constrain6dof.SetAngularLimits(angularLimitLow, angularLimitHigh);
+
+                        // tweek the constraint to increase stability
+                        constrain6dof.UseFrameOffset(useFrameOffset);
+                        constrain6dof.TranslationalLimitMotor(enableTransMotor, transMotorMaxVel, transMotorMaxForce);
+                        constrain6dof.SetCFMAndERP(cfm, erp);
+                        if (solverIterations != 0f)
+                        {
+                            constrain6dof.SetSolverIterations(solverIterations);
+                        }
+                    }
+                    break;
+                case ConstraintType.D6_SPRING_CONSTRAINT_TYPE:
+                    BSConstraintSpring constrainSpring = constrain as BSConstraintSpring;
+                    if (constrainSpring != null)
+                    {
+                        // zero linear and angular limits makes the objects unable to move in relation to each other
+                        constrainSpring.SetLinearLimits(linearLimitLow, linearLimitHigh);
+                        constrainSpring.SetAngularLimits(angularLimitLow, angularLimitHigh);
+
+                        // tweek the constraint to increase stability
+                        constrainSpring.UseFrameOffset(useFrameOffset);
+                        constrainSpring.TranslationalLimitMotor(enableTransMotor, transMotorMaxVel, transMotorMaxForce);
+                        constrainSpring.SetCFMAndERP(cfm, erp);
+                        if (solverIterations != 0f)
+                        {
+                            constrainSpring.SetSolverIterations(solverIterations);
+                        }
+                        for (int ii = 0; ii < springAxisEnable.Length; ii++)
+                        {
+                            constrainSpring.SetAxisEnable(ii, springAxisEnable[ii]);
+                            if (springDamping[ii] != BSAPITemplate.SPRING_NOT_SPECIFIED)
+                                constrainSpring.SetDamping(ii, springDamping[ii]);
+                            if (springStiffness[ii] != BSAPITemplate.SPRING_NOT_SPECIFIED)
+                                constrainSpring.SetStiffness(ii, springStiffness[ii]);
+                        }
+                        constrainSpring.CalculateTransforms();
+
+                        if (springLinearEquilibriumPoint != OMV.Vector3.Zero)
+                            constrainSpring.SetEquilibriumPoint(springLinearEquilibriumPoint, springAngularEquilibriumPoint);
+                        else
+                            constrainSpring.SetEquilibriumPoint(BSAPITemplate.SPRING_NOT_SPECIFIED, BSAPITemplate.SPRING_NOT_SPECIFIED);
+                    }
+                    break;
+                default:
+                    break;
+            }
+        }
+
+        // Return 'true' if the property updates from the physics engine should be reported
+        //    to the simulator.
+        // If the constraint is fixed, we don't need to report as the simulator and viewer will
+        //    report the right things.
+        public override bool ShouldUpdateChildProperties()
+        {
+            bool ret = true;
+            if (constraintType == ConstraintType.FIXED_CONSTRAINT_TYPE)
+                ret = false;
+
+            return ret;
+        }
+    }
+
     public BSLinksetConstraints(BSScene scene, BSPrimLinkable parent) : base(scene, parent)
     {
+        LinksetImpl = LinksetImplementation.Constraint;
     }
 
+    private static string LogHeader = "[BULLETSIM LINKSET CONSTRAINT]";
+
     // When physical properties are changed the linkset needs to recalculate
     //   its internal properties.
     // This is queued in the 'post taint' queue so the
     //   refresh will happen once after all the other taints are applied.
     public override void Refresh(BSPrimLinkable requestor)
     {
+        ScheduleRebuild(requestor);
         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
-            PhysicsScene.PostTaintObject("BSLinksetContraints.Refresh", requestor.LocalID, delegate()
+            m_physicsScene.PostTaintObject("BSLinksetContraints.Refresh", requestor.LocalID, delegate()
+            {
+                if (HasAnyChildren)
                 {
-                    if (HasAnyChildren && IsRoot(requestor))
-                        RecomputeLinksetConstraints();
-                });
+                    // Constraints that have not been changed are not rebuild but make sure
+                    //     the constraint of the requestor is rebuilt.
+                    PhysicallyUnlinkAChildFromRoot(LinksetRoot, requestor);
+                    // Rebuild the linkset and all its constraints.
+                    RecomputeLinksetConstraints();
+                }
+            });
         }
     }
 
@@ -67,8 +237,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.
+            Refresh(LinksetRoot);
+        }
+        return ret;
     }
 
     // The object is going static (non-physical). Do any setup necessary for a static linkset.
@@ -78,8 +254,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.
+            Refresh(LinksetRoot);
+        }
+        return ret;
     }
 
     // Called at taint-time!!
@@ -93,11 +277,11 @@ public sealed class BSLinksetConstraints : BSLinkset
     //     up to rebuild the constraints before the next simulation step.
     // Returns 'true' of something was actually removed and would need restoring
     // Called at taint-time!!
-    public override bool RemoveBodyDependencies(BSPrimLinkable child)
+    public override bool RemoveDependencies(BSPrimLinkable child)
     {
         bool ret = false;
 
-        DetailLog("{0},BSLinksetConstraint.RemoveBodyDependencies,removeChildrenForRoot,rID={1},rBody={2}",
+        DetailLog("{0},BSLinksetConstraint.RemoveDependencies,removeChildrenForRoot,rID={1},rBody={2}",
                                     child.LocalID, LinksetRoot.LocalID, LinksetRoot.PhysBody.AddrString);
 
         lock (m_linksetActivityLock)
@@ -118,7 +302,7 @@ public sealed class BSLinksetConstraints : BSLinkset
     {
         if (!HasChild(child))
         {
-            m_children.Add(child);
+            m_children.Add(child, new BSLinkInfoConstraint(child));
 
             DetailLog("{0},BSLinksetConstraints.AddChildToLinkset,call,child={1}", LinksetRoot.LocalID, child.LocalID);
 
@@ -130,7 +314,7 @@ public sealed class BSLinksetConstraints : BSLinkset
 
     // Remove the specified child from the linkset.
     // Safe to call even if the child is not really in my linkset.
-    protected override void RemoveChildFromLinkset(BSPrimLinkable child)
+    protected override void RemoveChildFromLinkset(BSPrimLinkable child, bool inTaintTime)
     {
         if (m_children.Remove(child))
         {
@@ -142,7 +326,7 @@ public sealed class BSLinksetConstraints : BSLinkset
                             rootx.LocalID, rootx.PhysBody.AddrString,
                             childx.LocalID, childx.PhysBody.AddrString);
 
-            PhysicsScene.TaintedObject("BSLinksetConstraints.RemoveChildFromLinkset", delegate()
+            m_physicsScene.TaintedObject(inTaintTime, childx.LocalID, "BSLinksetConstraints.RemoveChildFromLinkset", delegate()
             {
                 PhysicallyUnlinkAChildFromRoot(rootx, childx);
             });
@@ -165,73 +349,86 @@ public sealed class BSLinksetConstraints : BSLinkset
         Refresh(rootPrim);
     }
 
-    private BSConstraint BuildConstraint(BSPrimLinkable rootPrim, BSPrimLinkable childPrim)
+    // Create a static constraint between the two passed objects
+    private BSConstraint BuildConstraint(BSPrimLinkable rootPrim, BSLinkInfo li)
     {
+        BSLinkInfoConstraint linkInfo = li as BSLinkInfoConstraint;
+        if (linkInfo == null)
+            return null;
+
         // Zero motion for children so they don't interpolate
-        childPrim.ZeroMotion(true);
-
-        // Relative position normalized to the root prim
-        // Essentually a vector pointing from center of rootPrim to center of childPrim
-        OMV.Vector3 childRelativePosition = childPrim.Position - rootPrim.Position;
-
-        // real world coordinate of midpoint between the two objects
-        OMV.Vector3 midPoint = rootPrim.Position + (childRelativePosition / 2);
-
-        DetailLog("{0},BSLinksetConstraint.BuildConstraint,taint,root={1},rBody={2},child={3},cBody={4},rLoc={5},cLoc={6},midLoc={7}",
-                                        rootPrim.LocalID,
-                                        rootPrim.LocalID, rootPrim.PhysBody.AddrString,
-                                        childPrim.LocalID, childPrim.PhysBody.AddrString,
-                                        rootPrim.Position, childPrim.Position, midPoint);
-
-        // create a constraint that allows no freedom of movement between the two objects
-        // http://bulletphysics.org/Bullet/phpBB3/viewtopic.php?t=4818
-
-        BSConstraint6Dof constrain = new BSConstraint6Dof(
-                            PhysicsScene.World, rootPrim.PhysBody, childPrim.PhysBody, midPoint, true, true );
-                            // PhysicsScene.World, childPrim.BSBody, rootPrim.BSBody, midPoint, true, true );
-
-        /* NOTE: below is an attempt to build constraint with full frame computation, etc.
-         *     Using the midpoint is easier since it lets the Bullet code manipulate the transforms
-         *     of the objects.
-         * Code left for future programmers.
-        // ==================================================================================
-        // relative position normalized to the root prim
-        OMV.Quaternion invThisOrientation = OMV.Quaternion.Inverse(rootPrim.Orientation);
-        OMV.Vector3 childRelativePosition = (childPrim.Position - rootPrim.Position) * invThisOrientation;
-
-        // relative rotation of the child to the parent
-        OMV.Quaternion childRelativeRotation = invThisOrientation * childPrim.Orientation;
-        OMV.Quaternion inverseChildRelativeRotation = OMV.Quaternion.Inverse(childRelativeRotation);
-
-        DetailLog("{0},BSLinksetConstraint.PhysicallyLinkAChildToRoot,taint,root={1},child={2}", rootPrim.LocalID, rootPrim.LocalID, childPrim.LocalID);
-        BS6DofConstraint constrain = new BS6DofConstraint(
-                        PhysicsScene.World, rootPrim.Body, childPrim.Body,
-                        OMV.Vector3.Zero,
-                        OMV.Quaternion.Inverse(rootPrim.Orientation),
-                        OMV.Vector3.Zero,
-                        OMV.Quaternion.Inverse(childPrim.Orientation),
-                        true,
-                        true
-                        );
-        // ==================================================================================
-        */
-
-        PhysicsScene.Constraints.AddConstraint(constrain);
-
-        // zero linear and angular limits makes the objects unable to move in relation to each other
-        constrain.SetLinearLimits(OMV.Vector3.Zero, OMV.Vector3.Zero);
-        constrain.SetAngularLimits(OMV.Vector3.Zero, OMV.Vector3.Zero);
-
-        // tweek the constraint to increase stability
-        constrain.UseFrameOffset(BSParam.LinkConstraintUseFrameOffset);
-        constrain.TranslationalLimitMotor(BSParam.LinkConstraintEnableTransMotor,
-                        BSParam.LinkConstraintTransMotorMaxVel,
-                        BSParam.LinkConstraintTransMotorMaxForce);
-        constrain.SetCFMAndERP(BSParam.LinkConstraintCFM, BSParam.LinkConstraintERP);
-        if (BSParam.LinkConstraintSolverIterations != 0f)
+        li.member.ZeroMotion(true);
+
+        BSConstraint constrain = null;
+
+        switch (linkInfo.constraintType)
         {
-            constrain.SetSolverIterations(BSParam.LinkConstraintSolverIterations);
+            case ConstraintType.FIXED_CONSTRAINT_TYPE:
+            case ConstraintType.D6_CONSTRAINT_TYPE:
+                // Relative position normalized to the root prim
+                // Essentually a vector pointing from center of rootPrim to center of li.member
+                OMV.Vector3 childRelativePosition = linkInfo.member.Position - rootPrim.Position;
+
+                // real world coordinate of midpoint between the two objects
+                OMV.Vector3 midPoint = rootPrim.Position + (childRelativePosition / 2);
+
+                DetailLog("{0},BSLinksetConstraint.BuildConstraint,6Dof,rBody={1},cBody={2},rLoc={3},cLoc={4},midLoc={5}",
+                                                rootPrim.LocalID, rootPrim.PhysBody, linkInfo.member.PhysBody,
+                                                rootPrim.Position, linkInfo.member.Position, midPoint);
+
+                // create a constraint that allows no freedom of movement between the two objects
+                // http://bulletphysics.org/Bullet/phpBB3/viewtopic.php?t=4818
+
+                constrain = new BSConstraint6Dof(
+                                    m_physicsScene.World, rootPrim.PhysBody, linkInfo.member.PhysBody, midPoint, true, true );
+
+                /* NOTE: below is an attempt to build constraint with full frame computation, etc.
+                 *     Using the midpoint is easier since it lets the Bullet code manipulate the transforms
+                 *     of the objects.
+                 * Code left for future programmers.
+                // ==================================================================================
+                // relative position normalized to the root prim
+                OMV.Quaternion invThisOrientation = OMV.Quaternion.Inverse(rootPrim.Orientation);
+                OMV.Vector3 childRelativePosition = (liConstraint.member.Position - rootPrim.Position) * invThisOrientation;
+
+                // relative rotation of the child to the parent
+                OMV.Quaternion childRelativeRotation = invThisOrientation * liConstraint.member.Orientation;
+                OMV.Quaternion inverseChildRelativeRotation = OMV.Quaternion.Inverse(childRelativeRotation);
+
+                DetailLog("{0},BSLinksetConstraint.PhysicallyLinkAChildToRoot,taint,root={1},child={2}", rootPrim.LocalID, rootPrim.LocalID, liConstraint.member.LocalID);
+                constrain = new BS6DofConstraint(
+                                PhysicsScene.World, rootPrim.Body, liConstraint.member.Body,
+                                OMV.Vector3.Zero,
+                                OMV.Quaternion.Inverse(rootPrim.Orientation),
+                                OMV.Vector3.Zero,
+                                OMV.Quaternion.Inverse(liConstraint.member.Orientation),
+                                true,
+                                true
+                                );
+                // ==================================================================================
+                */
+
+                break;
+            case ConstraintType.D6_SPRING_CONSTRAINT_TYPE:
+                constrain = new BSConstraintSpring(m_physicsScene.World, rootPrim.PhysBody, linkInfo.member.PhysBody,
+                                linkInfo.frameInAloc, linkInfo.frameInArot, linkInfo.frameInBloc, linkInfo.frameInBrot,
+                                linkInfo.useLinearReferenceFrameA,
+                                true /*disableCollisionsBetweenLinkedBodies*/);
+                DetailLog("{0},BSLinksetConstraint.BuildConstraint,spring,root={1},rBody={2},child={3},cBody={4},rLoc={5},cLoc={6}",
+                                                rootPrim.LocalID,
+                                                rootPrim.LocalID, rootPrim.PhysBody.AddrString,
+                                                linkInfo.member.LocalID, linkInfo.member.PhysBody.AddrString,
+                                                rootPrim.Position, linkInfo.member.Position);
+
+                break;
+            default:
+                break;
         }
+
+        linkInfo.SetLinkParameters(constrain);
+
+        m_physicsScene.Constraints.AddConstraint(constrain);
+
         return constrain;
     }
 
@@ -247,13 +444,22 @@ public sealed class BSLinksetConstraints : BSLinkset
                             rootPrim.LocalID, rootPrim.PhysBody.AddrString,
                             childPrim.LocalID, childPrim.PhysBody.AddrString);
 
-        // Find the constraint for this link and get rid of it from the overall collection and from my list
-        if (PhysicsScene.Constraints.RemoveAndDestroyConstraint(rootPrim.PhysBody, childPrim.PhysBody))
+        // If asked to unlink root from root, just remove all the constraints
+        if (rootPrim == childPrim || childPrim == LinksetRoot)
         {
-            // Make the child refresh its location
-            PhysicsScene.PE.PushUpdate(childPrim.PhysBody);
+            PhysicallyUnlinkAllChildrenFromRoot(LinksetRoot);
             ret = true;
         }
+        else
+        {
+            // Find the constraint for this link and get rid of it from the overall collection and from my list
+            if (m_physicsScene.Constraints.RemoveAndDestroyConstraint(rootPrim.PhysBody, childPrim.PhysBody))
+            {
+                // Make the child refresh its location
+                m_physicsScene.PE.PushUpdate(childPrim.PhysBody);
+                ret = true;
+            }
+        }
 
         return ret;
     }
@@ -265,7 +471,7 @@ public sealed class BSLinksetConstraints : BSLinkset
     {
         DetailLog("{0},BSLinksetConstraint.PhysicallyUnlinkAllChildren,taint", rootPrim.LocalID);
 
-        return PhysicsScene.Constraints.RemoveAndDestroyConstraint(rootPrim.PhysBody);
+        return m_physicsScene.Constraints.RemoveAndDestroyConstraint(rootPrim.PhysBody);
     }
 
     // Call each of the constraints that make up this linkset and recompute the
@@ -281,24 +487,360 @@ 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 (!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 || !HasAnyChildren)
             {
-                // If constraint doesn't exist yet, create it.
-                constrain = BuildConstraint(LinksetRoot, child);
+                DetailLog("{0},BSLinksetConstraint.RecomputeLinksetCompound,notPhysicalOrNoChildren", 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
+            ForEachLinkInfo((li) =>
+            {
+                // 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.)
+                li.member.UpdatePhysicalMassProperties(linksetMass, true);
+
+                BSConstraint constrain;
+                if (!m_physicsScene.Constraints.TryGetConstraint(LinksetRoot.PhysBody, li.member.PhysBody, out constrain))
+                {
+                    // If constraint doesn't exist yet, create it.
+                    constrain = BuildConstraint(LinksetRoot, li);
+                }
+                li.SetLinkParameters(constrain);
+                constrain.RecomputeConstraintVariables(linksetMass);
+
+                // PhysicsScene.PE.DumpConstraint(PhysicsScene.World, constrain.Constraint);    // DEBUG DEBUG
+                return false;   // 'false' says to keep processing other members
+            });
         }
+        finally
+        {
+            Rebuilding = false;
+        }
+    }
 
+    #region Extension
+    public override object Extension(string pFunct, params object[] pParams)
+    {
+        object ret = null;
+        switch (pFunct)
+        {
+            // pParams = [ BSPhysObject root, BSPhysObject child, integer linkType ]
+            case ExtendedPhysics.PhysFunctChangeLinkType:
+                if (pParams.Length > 2)
+                {
+                    int requestedType = (int)pParams[2];
+                    DetailLog("{0},BSLinksetConstraint.ChangeLinkType,requestedType={1}", LinksetRoot.LocalID, requestedType);
+                    if (requestedType == (int)ConstraintType.FIXED_CONSTRAINT_TYPE
+                        || requestedType == (int)ConstraintType.D6_CONSTRAINT_TYPE
+                        || requestedType == (int)ConstraintType.D6_SPRING_CONSTRAINT_TYPE
+                        || requestedType == (int)ConstraintType.HINGE_CONSTRAINT_TYPE
+                        || requestedType == (int)ConstraintType.CONETWIST_CONSTRAINT_TYPE
+                        || requestedType == (int)ConstraintType.SLIDER_CONSTRAINT_TYPE)
+                    {
+                        BSPrimLinkable child = pParams[1] as BSPrimLinkable;
+                        if (child != null)
+                        {
+                            DetailLog("{0},BSLinksetConstraint.ChangeLinkType,rootID={1},childID={2},type={3}",
+                                                    LinksetRoot.LocalID, LinksetRoot.LocalID, child.LocalID, requestedType);
+                            m_physicsScene.TaintedObject(child.LocalID, "BSLinksetConstraint.PhysFunctChangeLinkType", delegate()
+                            {
+                                // Pick up all the constraints currently created.
+                                RemoveDependencies(child);
+
+                                BSLinkInfo linkInfo = null;
+                                if (TryGetLinkInfo(child, out linkInfo))
+                                {
+                                    BSLinkInfoConstraint linkInfoC = linkInfo as BSLinkInfoConstraint;
+                                    if (linkInfoC != null)
+                                    {
+                                        linkInfoC.constraintType = (ConstraintType)requestedType;
+                                        ret = (object)true;
+                                        DetailLog("{0},BSLinksetConstraint.ChangeLinkType,link={1},type={2}",
+                                                    linkInfo.member.LocalID, linkInfo.member.LocalID, linkInfoC.constraintType);
+                                    }
+                                    else
+                                    {
+                                        DetailLog("{0},BSLinksetConstraint.ChangeLinkType,linkInfoNotConstraint,childID={1}", LinksetRoot.LocalID, child.LocalID);
+                                    }
+                                }
+                                else
+                                {
+                                    DetailLog("{0},BSLinksetConstraint.ChangeLinkType,noLinkInfoForChild,childID={1}", LinksetRoot.LocalID, child.LocalID);
+                                }
+                                // Cause the whole linkset to be rebuilt in post-taint time.
+                                Refresh(child);
+                            });
+                        }
+                        else
+                        {
+                            DetailLog("{0},BSLinksetConstraint.SetLinkType,childNotBSPrimLinkable", LinksetRoot.LocalID);
+                        }
+                    }
+                    else
+                    {
+                        DetailLog("{0},BSLinksetConstraint.SetLinkType,illegalRequestedType,reqested={1},spring={2}",
+                                        LinksetRoot.LocalID, requestedType, ((int)ConstraintType.D6_SPRING_CONSTRAINT_TYPE));
+                    }
+                }
+                break;
+            // pParams = [ BSPhysObject root, BSPhysObject child ]
+            case ExtendedPhysics.PhysFunctGetLinkType:
+                if (pParams.Length > 0)
+                {
+                    BSPrimLinkable child = pParams[1] as BSPrimLinkable;
+                    if (child != null)
+                    {
+                        BSLinkInfo linkInfo = null;
+                        if (TryGetLinkInfo(child, out linkInfo))
+                        {
+                            BSLinkInfoConstraint linkInfoC = linkInfo as BSLinkInfoConstraint;
+                            if (linkInfoC != null)
+                            {
+                                ret = (object)(int)linkInfoC.constraintType;
+                                DetailLog("{0},BSLinksetConstraint.GetLinkType,link={1},type={2}",
+                                            linkInfo.member.LocalID, linkInfo.member.LocalID, linkInfoC.constraintType);
+
+                            }
+                        }
+                    }
+                }
+                break;
+            // pParams = [ BSPhysObject root, BSPhysObject child, int op, object opParams, int op, object opParams, ... ]
+            case ExtendedPhysics.PhysFunctChangeLinkParams:
+                // There should be two parameters: the childActor and a list of parameters to set
+                if (pParams.Length > 2)
+                {
+                    BSPrimLinkable child = pParams[1] as BSPrimLinkable;
+                    BSLinkInfo baseLinkInfo = null;
+                    if (TryGetLinkInfo(child, out baseLinkInfo))
+                    {
+                        BSLinkInfoConstraint linkInfo = baseLinkInfo as BSLinkInfoConstraint;
+                        if (linkInfo != null)
+                        {
+                            int valueInt;
+                            float valueFloat;
+                            bool valueBool;
+                            OMV.Vector3 valueVector;
+                            OMV.Vector3 valueVector2;
+                            OMV.Quaternion valueQuaternion;
+                            int axisLow, axisHigh;
+
+                            int opIndex = 2;
+                            while (opIndex < pParams.Length)
+                            {
+                                int thisOp = 0;
+                                string errMsg = "";
+                                try
+                                {
+                                    thisOp = (int)pParams[opIndex];
+                                    DetailLog("{0},BSLinksetConstraint.ChangeLinkParams2,op={1},val={2}",
+                                                        linkInfo.member.LocalID, thisOp, pParams[opIndex + 1]);
+                                    switch (thisOp)
+                                    {
+                                        case ExtendedPhysics.PHYS_PARAM_LINK_TYPE:
+                                            valueInt = (int)pParams[opIndex + 1];
+                                            ConstraintType valueType = (ConstraintType)valueInt;
+                                            if (valueType == ConstraintType.FIXED_CONSTRAINT_TYPE
+                                                || valueType == ConstraintType.D6_CONSTRAINT_TYPE
+                                                || valueType == ConstraintType.D6_SPRING_CONSTRAINT_TYPE
+                                                || valueType == ConstraintType.HINGE_CONSTRAINT_TYPE
+                                                || valueType == ConstraintType.CONETWIST_CONSTRAINT_TYPE
+                                                || valueType == ConstraintType.SLIDER_CONSTRAINT_TYPE)
+                                            {
+                                                linkInfo.constraintType = valueType;
+                                            }
+                                            opIndex += 2;
+                                            break;
+                                        case ExtendedPhysics.PHYS_PARAM_FRAMEINA_LOC:
+                                            errMsg = "PHYS_PARAM_FRAMEINA_LOC takes one parameter of type vector";
+                                            valueVector = (OMV.Vector3)pParams[opIndex + 1];
+                                            linkInfo.frameInAloc = valueVector;
+                                            opIndex += 2;
+                                            break;
+                                        case ExtendedPhysics.PHYS_PARAM_FRAMEINA_ROT:
+                                            errMsg = "PHYS_PARAM_FRAMEINA_ROT takes one parameter of type rotation";
+                                            valueQuaternion = (OMV.Quaternion)pParams[opIndex + 1];
+                                            linkInfo.frameInArot = valueQuaternion;
+                                            opIndex += 2;
+                                            break;
+                                        case ExtendedPhysics.PHYS_PARAM_FRAMEINB_LOC:
+                                            errMsg = "PHYS_PARAM_FRAMEINB_LOC takes one parameter of type vector";
+                                            valueVector = (OMV.Vector3)pParams[opIndex + 1];
+                                            linkInfo.frameInBloc = valueVector;
+                                            opIndex += 2;
+                                            break;
+                                        case ExtendedPhysics.PHYS_PARAM_FRAMEINB_ROT:
+                                            errMsg = "PHYS_PARAM_FRAMEINB_ROT takes one parameter of type rotation";
+                                            valueQuaternion = (OMV.Quaternion)pParams[opIndex + 1];
+                                            linkInfo.frameInBrot = valueQuaternion;
+                                            opIndex += 2;
+                                            break;
+                                        case ExtendedPhysics.PHYS_PARAM_LINEAR_LIMIT_LOW:
+                                            errMsg = "PHYS_PARAM_LINEAR_LIMIT_LOW takes one parameter of type vector";
+                                            valueVector = (OMV.Vector3)pParams[opIndex + 1];
+                                            linkInfo.linearLimitLow = valueVector;
+                                            opIndex += 2;
+                                            break;
+                                        case ExtendedPhysics.PHYS_PARAM_LINEAR_LIMIT_HIGH:
+                                            errMsg = "PHYS_PARAM_LINEAR_LIMIT_HIGH takes one parameter of type vector";
+                                            valueVector = (OMV.Vector3)pParams[opIndex + 1];
+                                            linkInfo.linearLimitHigh = valueVector;
+                                            opIndex += 2;
+                                            break;
+                                        case ExtendedPhysics.PHYS_PARAM_ANGULAR_LIMIT_LOW:
+                                            errMsg = "PHYS_PARAM_ANGULAR_LIMIT_LOW takes one parameter of type vector";
+                                            valueVector = (OMV.Vector3)pParams[opIndex + 1];
+                                            linkInfo.angularLimitLow = valueVector;
+                                            opIndex += 2;
+                                            break;
+                                        case ExtendedPhysics.PHYS_PARAM_ANGULAR_LIMIT_HIGH:
+                                            errMsg = "PHYS_PARAM_ANGULAR_LIMIT_HIGH takes one parameter of type vector";
+                                            valueVector = (OMV.Vector3)pParams[opIndex + 1];
+                                            linkInfo.angularLimitHigh = valueVector;
+                                            opIndex += 2;
+                                            break;
+                                        case ExtendedPhysics.PHYS_PARAM_USE_FRAME_OFFSET:
+                                            errMsg = "PHYS_PARAM_USE_FRAME_OFFSET takes one parameter of type integer (bool)";
+                                            valueBool = ((int)pParams[opIndex + 1]) != 0;
+                                            linkInfo.useFrameOffset = valueBool;
+                                            opIndex += 2;
+                                            break;
+                                        case ExtendedPhysics.PHYS_PARAM_ENABLE_TRANSMOTOR:
+                                            errMsg = "PHYS_PARAM_ENABLE_TRANSMOTOR takes one parameter of type integer (bool)";
+                                            valueBool = ((int)pParams[opIndex + 1]) != 0;
+                                            linkInfo.enableTransMotor = valueBool;
+                                            opIndex += 2;
+                                            break;
+                                        case ExtendedPhysics.PHYS_PARAM_TRANSMOTOR_MAXVEL:
+                                            errMsg = "PHYS_PARAM_TRANSMOTOR_MAXVEL takes one parameter of type float";
+                                            valueFloat = (float)pParams[opIndex + 1];
+                                            linkInfo.transMotorMaxVel = valueFloat;
+                                            opIndex += 2;
+                                            break;
+                                        case ExtendedPhysics.PHYS_PARAM_TRANSMOTOR_MAXFORCE:
+                                            errMsg = "PHYS_PARAM_TRANSMOTOR_MAXFORCE takes one parameter of type float";
+                                            valueFloat = (float)pParams[opIndex + 1];
+                                            linkInfo.transMotorMaxForce = valueFloat;
+                                            opIndex += 2;
+                                            break;
+                                        case ExtendedPhysics.PHYS_PARAM_CFM:
+                                            errMsg = "PHYS_PARAM_CFM takes one parameter of type float";
+                                            valueFloat = (float)pParams[opIndex + 1];
+                                            linkInfo.cfm = valueFloat;
+                                            opIndex += 2;
+                                            break;
+                                        case ExtendedPhysics.PHYS_PARAM_ERP:
+                                            errMsg = "PHYS_PARAM_ERP takes one parameter of type float";
+                                            valueFloat = (float)pParams[opIndex + 1];
+                                            linkInfo.erp = valueFloat;
+                                            opIndex += 2;
+                                            break;
+                                        case ExtendedPhysics.PHYS_PARAM_SOLVER_ITERATIONS:
+                                            errMsg = "PHYS_PARAM_SOLVER_ITERATIONS takes one parameter of type float";
+                                            valueFloat = (float)pParams[opIndex + 1];
+                                            linkInfo.solverIterations = valueFloat;
+                                            opIndex += 2;
+                                            break;
+                                        case ExtendedPhysics.PHYS_PARAM_SPRING_AXIS_ENABLE:
+                                            errMsg = "PHYS_PARAM_SPRING_AXIS_ENABLE takes two parameters of types integer and integer (bool)";
+                                            valueInt = (int)pParams[opIndex + 1];
+                                            valueBool = ((int)pParams[opIndex + 2]) != 0;
+                                            GetAxisRange(valueInt, out axisLow, out axisHigh);
+                                            for (int ii = axisLow; ii <= axisHigh; ii++)
+                                                linkInfo.springAxisEnable[ii] = valueBool;
+                                            opIndex += 3;
+                                            break;
+                                        case ExtendedPhysics.PHYS_PARAM_SPRING_DAMPING:
+                                            errMsg = "PHYS_PARAM_SPRING_DAMPING takes two parameters of types integer and float";
+                                            valueInt = (int)pParams[opIndex + 1];
+                                            valueFloat = (float)pParams[opIndex + 2];
+                                            GetAxisRange(valueInt, out axisLow, out axisHigh);
+                                            for (int ii = axisLow; ii <= axisHigh; ii++)
+                                                linkInfo.springDamping[ii] = valueFloat;
+                                            opIndex += 3;
+                                            break;
+                                        case ExtendedPhysics.PHYS_PARAM_SPRING_STIFFNESS:
+                                            errMsg = "PHYS_PARAM_SPRING_STIFFNESS takes two parameters of types integer and float";
+                                            valueInt = (int)pParams[opIndex + 1];
+                                            valueFloat = (float)pParams[opIndex + 2];
+                                            GetAxisRange(valueInt, out axisLow, out axisHigh);
+                                            for (int ii = axisLow; ii <= axisHigh; ii++)
+                                                linkInfo.springStiffness[ii] = valueFloat;
+                                            opIndex += 3;
+                                            break;
+                                        case ExtendedPhysics.PHYS_PARAM_SPRING_EQUILIBRIUM_POINT:
+                                            errMsg = "PHYS_PARAM_SPRING_EQUILIBRIUM_POINT takes two parameters of type vector";
+                                            valueVector = (OMV.Vector3)pParams[opIndex + 1];
+                                            valueVector2 = (OMV.Vector3)pParams[opIndex + 2];
+                                            linkInfo.springLinearEquilibriumPoint = valueVector;
+                                            linkInfo.springAngularEquilibriumPoint = valueVector2;
+                                            opIndex += 3;
+                                            break;
+                                        case ExtendedPhysics.PHYS_PARAM_USE_LINEAR_FRAMEA:
+                                            errMsg = "PHYS_PARAM_USE_LINEAR_FRAMEA takes one parameter of type integer (bool)";
+                                            valueBool = ((int)pParams[opIndex + 1]) != 0;
+                                            linkInfo.useLinearReferenceFrameA = valueBool;
+                                            opIndex += 2;
+                                            break;
+                                        default:
+                                            break;
+                                    }
+                                }
+                                catch (InvalidCastException e)
+                                {
+                                    m_physicsScene.Logger.WarnFormat("{0} value of wrong type in physSetLinksetParams: {1}, err={2}",
+                                                        LogHeader, errMsg, e);
+                                }
+                                catch (Exception e)
+                                {
+                                    m_physicsScene.Logger.WarnFormat("{0} bad parameters in physSetLinksetParams: {1}", LogHeader, e);
+                                }
+                            }
+                        }
+                        // Something changed so a rebuild is in order
+                        Refresh(child);
+                    }
+                }
+            break;
+            default:
+                ret = base.Extension(pFunct, pParams);
+                break;
+        }
+        return ret;
+    }
+
+    // Bullet constraints keep some limit parameters for each linear and angular axis.
+    // Setting same is easier if there is an easy way to see all or types.
+    // This routine returns the array limits for the set of axis.
+    private void GetAxisRange(int rangeSpec, out int low, out int high)
+    {
+        switch (rangeSpec)
+        {
+            case ExtendedPhysics.PHYS_AXIS_LINEAR_ALL:
+                low = 0;
+                high = 2;
+                break;
+            case ExtendedPhysics.PHYS_AXIS_ANGULAR_ALL:
+                low = 3;
+                high = 5;
+                break;
+            case ExtendedPhysics.PHYS_AXIS_ALL:
+                low = 0;
+                high = 5;
+                break;
+            default:
+                low = high = rangeSpec;
+                break;
+        }
+        return;
     }
+    #endregion // Extension
+
 }
 }
diff --git a/OpenSim/Region/Physics/BulletSPlugin/BSMotors.cs b/OpenSim/Region/Physics/BulletSPlugin/BSMotors.cs
index 9501e2d..7693195 100755
--- a/OpenSim/Region/Physics/BulletSPlugin/BSMotors.cs
+++ b/OpenSim/Region/Physics/BulletSPlugin/BSMotors.cs
@@ -65,13 +65,11 @@ public abstract class BSMotor
 }
 
 // Motor which moves CurrentValue to TargetValue over TimeScale seconds.
-// The TargetValue decays in TargetValueDecayTimeScale and
-//     the CurrentValue will be held back by FrictionTimeScale.
+// The TargetValue decays in TargetValueDecayTimeScale.
 // This motor will "zero itself" over time in that the targetValue will
 //    decay to zero and the currentValue will follow it to that zero.
 //    The overall effect is for the returned correction value to go from large
-//    values (the total difference between current and target minus friction)
-//    to small and eventually zero values.
+//    values to small and eventually zero values.
 // TimeScale and TargetDelayTimeScale may be 'infinite' which means no decay.
 
 // For instance, if something is moving at speed X and the desired speed is Y,
@@ -88,7 +86,6 @@ public class BSVMotor : BSMotor
 
     public virtual float TimeScale { get; set; }
     public virtual float TargetValueDecayTimeScale { get; set; }
-    public virtual Vector3 FrictionTimescale { get; set; }
     public virtual float Efficiency { get; set; }
 
     public virtual float ErrorZeroThreshold { get; set; }
@@ -102,7 +99,7 @@ public class BSVMotor : BSMotor
         return ErrorIsZero(LastError);
     }
     public virtual bool ErrorIsZero(Vector3 err)
-    { 
+    {
         return (err == Vector3.Zero || err.ApproxEquals(Vector3.Zero, ErrorZeroThreshold));
     }
 
@@ -111,16 +108,14 @@ public class BSVMotor : BSMotor
     {
         TimeScale = TargetValueDecayTimeScale = BSMotor.Infinite;
         Efficiency = 1f;
-        FrictionTimescale = BSMotor.InfiniteVector;
         CurrentValue = TargetValue = Vector3.Zero;
         ErrorZeroThreshold = 0.001f;
     }
-    public BSVMotor(string useName, float timeScale, float decayTimeScale, Vector3 frictionTimeScale, float efficiency) 
+    public BSVMotor(string useName, float timeScale, float decayTimeScale, float efficiency)
         : this(useName)
     {
         TimeScale = timeScale;
         TargetValueDecayTimeScale = decayTimeScale;
-        FrictionTimescale = frictionTimeScale;
         Efficiency = efficiency;
         CurrentValue = TargetValue = Vector3.Zero;
     }
@@ -149,7 +144,6 @@ public class BSVMotor : BSMotor
 
         Vector3 correction = Vector3.Zero;
         Vector3 error = TargetValue - CurrentValue;
-        LastError = error;
         if (!ErrorIsZero(error))
         {
             correction = StepError(timeStep, error);
@@ -165,26 +159,11 @@ public class BSVMotor : BSMotor
                 TargetValue *= (1f - decayFactor);
             }
 
-            // The amount we can correct the error is reduced by the friction
-            Vector3 frictionFactor = Vector3.Zero;
-            if (FrictionTimescale != BSMotor.InfiniteVector)
-            {
-                // frictionFactor = (Vector3.One / FrictionTimescale) * timeStep;
-                // Individual friction components can be 'infinite' so compute each separately.
-                frictionFactor.X = (FrictionTimescale.X == BSMotor.Infinite) ? 0f : (1f / FrictionTimescale.X);
-                frictionFactor.Y = (FrictionTimescale.Y == BSMotor.Infinite) ? 0f : (1f / FrictionTimescale.Y);
-                frictionFactor.Z = (FrictionTimescale.Z == BSMotor.Infinite) ? 0f : (1f / FrictionTimescale.Z);
-                frictionFactor *= timeStep;
-                CurrentValue *= (Vector3.One - frictionFactor);
-            }
-
             MDetailLog("{0},  BSVMotor.Step,nonZero,{1},origCurr={2},origTarget={3},timeStep={4},err={5},corr={6}",
                                 BSScene.DetailLogZero, UseName, origCurrVal, origTarget,
                                 timeStep, error, correction);
-            MDetailLog("{0},  BSVMotor.Step,nonZero,{1},tgtDecayTS={2},decayFact={3},frictTS={4},frictFact={5},tgt={6},curr={7}",
-                                BSScene.DetailLogZero, UseName,
-                                TargetValueDecayTimeScale, decayFactor, FrictionTimescale, frictionFactor,
-                                TargetValue, CurrentValue);
+            MDetailLog("{0},  BSVMotor.Step,nonZero,{1},tgtDecayTS={2},decayFact={3},tgt={4},curr={5}",
+                                BSScene.DetailLogZero, UseName, TargetValueDecayTimeScale, decayFactor, TargetValue, CurrentValue);
         }
         else
         {
@@ -199,6 +178,7 @@ public class BSVMotor : BSMotor
             MDetailLog("{0},  BSVMotor.Step,zero,{1},origTgt={2},origCurr={3},currTgt={4},currCurr={5}",
                         BSScene.DetailLogZero, UseName, origCurrVal, origTarget, TargetValue, CurrentValue);
         }
+        LastError = error;
 
         return correction;
     }
@@ -208,6 +188,8 @@ public class BSVMotor : BSMotor
         CurrentValue = current;
         return Step(timeStep);
     }
+    // Given and error, computer a correction for this step.
+    // Simple scaling of the error by the timestep.
     public virtual Vector3 StepError(float timeStep, Vector3 error)
     {
         if (!Enabled) return Vector3.Zero;
@@ -235,27 +217,27 @@ public class BSVMotor : BSMotor
         // maximum number of outputs to generate.
         int maxOutput = 50;
         MDetailLog("{0},BSVMotor.Test,{1},===================================== BEGIN Test Output", BSScene.DetailLogZero, UseName);
-        MDetailLog("{0},BSVMotor.Test,{1},timeScale={2},targDlyTS={3},frictTS={4},eff={5},curr={6},tgt={7}",
+        MDetailLog("{0},BSVMotor.Test,{1},timeScale={2},targDlyTS={3},eff={4},curr={5},tgt={6}",
                                 BSScene.DetailLogZero, UseName,
-                                TimeScale, TargetValueDecayTimeScale, FrictionTimescale, Efficiency, 
+                                TimeScale, TargetValueDecayTimeScale, Efficiency,
                                 CurrentValue, TargetValue);
 
         LastError = BSMotor.InfiniteVector;
-        while (maxOutput-- > 0 && !LastError.ApproxEquals(Vector3.Zero, ErrorZeroThreshold))
+        while (maxOutput-- > 0 && !ErrorIsZero())
         {
             Vector3 lastStep = Step(timeStep);
             MDetailLog("{0},BSVMotor.Test,{1},cur={2},tgt={3},lastError={4},lastStep={5}",
                             BSScene.DetailLogZero, UseName, CurrentValue, TargetValue, LastError, lastStep);
         }
         MDetailLog("{0},BSVMotor.Test,{1},===================================== END Test Output", BSScene.DetailLogZero, UseName);
-        
+
 
     }
 
     public override string ToString()
     {
-        return String.Format("<{0},curr={1},targ={2},lastErr={3},decayTS={4},frictTS={5}>",
-            UseName, CurrentValue, TargetValue, LastError, TargetValueDecayTimeScale, FrictionTimescale);
+        return String.Format("<{0},curr={1},targ={2},lastErr={3},decayTS={4}>",
+            UseName, CurrentValue, TargetValue, LastError, TargetValueDecayTimeScale);
     }
 }
 
@@ -265,7 +247,6 @@ public class BSFMotor : BSMotor
 {
     public virtual float TimeScale { get; set; }
     public virtual float TargetValueDecayTimeScale { get; set; }
-    public virtual float FrictionTimescale { get; set; }
     public virtual float Efficiency { get; set; }
 
     public virtual float ErrorZeroThreshold { get; set; }
@@ -279,16 +260,15 @@ public class BSFMotor : BSMotor
         return ErrorIsZero(LastError);
     }
     public virtual bool ErrorIsZero(float err)
-    { 
+    {
         return (err >= -ErrorZeroThreshold && err <= ErrorZeroThreshold);
     }
 
-    public BSFMotor(string useName, float timeScale, float decayTimescale, float friction, float efficiency)
+    public BSFMotor(string useName, float timeScale, float decayTimescale, float efficiency)
         : base(useName)
     {
         TimeScale = TargetValueDecayTimeScale = BSMotor.Infinite;
         Efficiency = 1f;
-        FrictionTimescale = BSMotor.Infinite;
         CurrentValue = TargetValue = 0f;
         ErrorZeroThreshold = 0.01f;
     }
@@ -315,7 +295,6 @@ public class BSFMotor : BSMotor
 
         float correction = 0f;
         float error = TargetValue - CurrentValue;
-        LastError = error;
         if (!ErrorIsZero(error))
         {
             correction = StepError(timeStep, error);
@@ -331,24 +310,11 @@ public class BSFMotor : BSMotor
                 TargetValue *= (1f - decayFactor);
             }
 
-            // The amount we can correct the error is reduced by the friction
-            float frictionFactor = 0f;
-            if (FrictionTimescale != BSMotor.Infinite)
-            {
-                // frictionFactor = (Vector3.One / FrictionTimescale) * timeStep;
-                // Individual friction components can be 'infinite' so compute each separately.
-                frictionFactor = 1f / FrictionTimescale;
-                frictionFactor *= timeStep;
-                CurrentValue *= (1f - frictionFactor);
-            }
-
             MDetailLog("{0},  BSFMotor.Step,nonZero,{1},origCurr={2},origTarget={3},timeStep={4},err={5},corr={6}",
                                 BSScene.DetailLogZero, UseName, origCurrVal, origTarget,
                                 timeStep, error, correction);
-            MDetailLog("{0},  BSFMotor.Step,nonZero,{1},tgtDecayTS={2},decayFact={3},frictTS={4},frictFact={5},tgt={6},curr={7}",
-                                BSScene.DetailLogZero, UseName,
-                                TargetValueDecayTimeScale, decayFactor, FrictionTimescale, frictionFactor,
-                                TargetValue, CurrentValue);
+            MDetailLog("{0},  BSFMotor.Step,nonZero,{1},tgtDecayTS={2},decayFact={3},tgt={4},curr={5}",
+                                BSScene.DetailLogZero, UseName, TargetValueDecayTimeScale, decayFactor, TargetValue, CurrentValue);
         }
         else
         {
@@ -363,6 +329,7 @@ public class BSFMotor : BSMotor
             MDetailLog("{0},  BSFMotor.Step,zero,{1},origTgt={2},origCurr={3},ret={4}",
                         BSScene.DetailLogZero, UseName, origCurrVal, origTarget, CurrentValue);
         }
+        LastError = error;
 
         return CurrentValue;
     }
@@ -390,15 +357,15 @@ public class BSFMotor : BSMotor
 
     public override string ToString()
     {
-        return String.Format("<{0},curr={1},targ={2},lastErr={3},decayTS={4},frictTS={5}>",
-            UseName, CurrentValue, TargetValue, LastError, TargetValueDecayTimeScale, FrictionTimescale);
+        return String.Format("<{0},curr={1},targ={2},lastErr={3},decayTS={4}>",
+            UseName, CurrentValue, TargetValue, LastError, TargetValueDecayTimeScale);
     }
 
 }
 
 // ============================================================================
 // ============================================================================
-// Proportional, Integral, Derivitive Motor
+// Proportional, Integral, Derivitive ("PID") Motor
 // Good description at http://www.answers.com/topic/pid-controller . Includes processes for choosing p, i and d factors.
 public class BSPIDVMotor : BSVMotor
 {
@@ -410,7 +377,6 @@ public class BSPIDVMotor : BSVMotor
     // The factors are vectors for the three dimensions. This is the proportional of each
     //    that is applied. This could be multiplied through the actual factors but it
     //    is sometimes easier to manipulate the factors and their mix separately.
-    //      to 
     public Vector3 FactorMix;
 
     // Arbritrary factor range.
@@ -448,14 +414,14 @@ public class BSPIDVMotor : BSVMotor
             // If efficiency is high (1f), use a factor value that moves the error value to zero with little overshoot.
             // If efficiency is low (0f), use a factor value that overcorrects.
             // TODO: might want to vary contribution of different factor depending on efficiency.
-            float factor = ((1f - this.Efficiency) * EfficiencyHigh + EfficiencyLow) / 3f;
-            // float factor = (1f - this.Efficiency) * EfficiencyHigh + EfficiencyLow;
+            // float factor = ((1f - this.Efficiency) * EfficiencyHigh + EfficiencyLow) / 3f;
+            float factor = (1f - this.Efficiency) * EfficiencyHigh + EfficiencyLow;
 
             proportionFactor = new Vector3(factor, factor, factor);
             integralFactor = new Vector3(factor, factor, factor);
             derivFactor = new Vector3(factor, factor, factor);
 
-            MDetailLog("{0},BSPIDVMotor.setEfficiency,eff={1},factor={2}", BSScene.DetailLogZero, Efficiency, factor);
+            MDetailLog("{0},  BSPIDVMotor.setEfficiency,eff={1},factor={2}", BSScene.DetailLogZero, Efficiency, factor);
         }
     }
 
@@ -469,16 +435,15 @@ public class BSPIDVMotor : BSVMotor
 
         // A simple derivitive is the rate of change from the last error.
         Vector3 derivitive = (error - LastError) * timeStep;
-        LastError = error;
 
         // Correction = (proportionOfPresentError + accumulationOfPastError + rateOfChangeOfError)
-        Vector3 ret   =   error * timeStep   * proportionFactor * FactorMix.X
-                        + RunningIntegration * integralFactor   * FactorMix.Y
-                        + derivitive         * derivFactor      * FactorMix.Z
+        Vector3 ret   =   error / TimeScale * timeStep   * proportionFactor * FactorMix.X
+                        + RunningIntegration / TimeScale * integralFactor   * FactorMix.Y
+                        + derivitive / TimeScale         * derivFactor      * FactorMix.Z
                         ;
 
-        MDetailLog("{0},BSPIDVMotor.step,ts={1},err={2},runnInt={3},deriv={4},ret={5}",
-                        BSScene.DetailLogZero, timeStep, error, RunningIntegration, derivitive, ret);
+        MDetailLog("{0},  BSPIDVMotor.step,ts={1},err={2},lerr={3},runnInt={4},deriv={5},ret={6}",
+                        BSScene.DetailLogZero, timeStep, error, LastError, RunningIntegration, derivitive, ret);
 
         return ret;
     }
diff --git a/OpenSim/Region/Physics/BulletSPlugin/BSParam.cs b/OpenSim/Region/Physics/BulletSPlugin/BSParam.cs
index 385ed9e..834228e 100755
--- a/OpenSim/Region/Physics/BulletSPlugin/BSParam.cs
+++ b/OpenSim/Region/Physics/BulletSPlugin/BSParam.cs
@@ -26,6 +26,7 @@
  */
 using System;
 using System.Collections.Generic;
+using System.Reflection;
 using System.Text;
 
 using OpenSim.Region.Physics.Manager;
@@ -37,7 +38,7 @@ namespace OpenSim.Region.Physics.BulletSPlugin
 {
 public static class BSParam
 {
-    private static string LogHeader = "[BULLETSIM PARAMETERS]"; 
+    private static string LogHeader = "[BULLETSIM PARAMETERS]";
 
     // Tuning notes:
     // From: http://bulletphysics.org/Bullet/phpBB3/viewtopic.php?t=6575
@@ -51,7 +52,10 @@ public static class BSParam
     //    This is separate/independent from the collision margin. The collision margin increases the object a bit
     //    to improve collision detection performance and accuracy.
     // ===================
-    // From: 
+    // From:
+
+    public static bool UseSeparatePhysicsThread { get; private set; }
+    public static float PhysicsTimeStep { get; private set; }
 
     // Level of Detail values kept as float because that's what the Meshmerizer wants
     public static float MeshLOD { get; private set; }
@@ -86,8 +90,12 @@ public static class BSParam
     public static bool ShouldForceSimplePrimMeshing { get; private set; }   // if a cube or sphere, let Bullet do internal shapes
     public static bool ShouldUseHullsForPhysicalObjects { get; private set; }   // 'true' if should create hulls for physical objects
     public static bool ShouldRemoveZeroWidthTriangles { get; private set; }
+    public static bool ShouldUseBulletHACD { get; set; }
+    public static bool ShouldUseSingleConvexHullForPrims { get; set; }
+    public static bool ShouldUseGImpactShapeForPrims { get; set; }
+    public static bool ShouldUseAssetHulls { get; set; }
 
-    public static float TerrainImplementation { get; private set; }
+    public static float TerrainImplementation { get; set; }
     public static int TerrainMeshMagnification { get; private set; }
     public static float TerrainFriction { get; private set; }
     public static float TerrainHitFraction { get; private set; }
@@ -112,6 +120,7 @@ public static class BSParam
         public static float NumberOfSolverIterations { get; private set; }
     public static bool UseSingleSidedMeshes { get; private set; }
     public static float GlobalContactBreakingThreshold { get; private set; }
+    public static float PhysicsUnmanLoggingFrames { get; private set; }
 
     // Avatar parameters
     public static float AvatarFriction { get; private set; }
@@ -122,11 +131,18 @@ public static class BSParam
     public static float AvatarCapsuleWidth { get; private set; }
     public static float AvatarCapsuleDepth { get; private set; }
     public static float AvatarCapsuleHeight { get; private set; }
+    public static float AvatarHeightLowFudge { get; private set; }
+    public static float AvatarHeightMidFudge { get; private set; }
+    public static float AvatarHeightHighFudge { get; private set; }
         public static float AvatarContactProcessingThreshold { get; private set; }
+    public static float AvatarStopZeroThreshold { get; private set; }
+        public static int AvatarJumpFrames { get; private set; }
         public static float AvatarBelowGroundUpCorrectionMeters { get; private set; }
         public static float AvatarStepHeight { get; private set; }
         public static float AvatarStepApproachFactor { get; private set; }
         public static float AvatarStepForceFactor { get; private set; }
+        public static float AvatarStepUpCorrectionFactor { get; private set; }
+        public static int AvatarStepSmoothingSteps { get; private set; }
 
     // Vehicle parameters
     public static float VehicleMaxLinearVelocity { get; private set; }
@@ -138,9 +154,15 @@ public static class BSParam
     public static float VehicleRestitution { get; private set; }
     public static Vector3 VehicleLinearFactor { get; private set; }
     public static Vector3 VehicleAngularFactor { get; private set; }
+    public static Vector3 VehicleInertiaFactor { get; private set; }
     public static float VehicleGroundGravityFudge { get; private set; }
     public static float VehicleAngularBankingTimescaleFudge { get; private set; }
-    public static bool VehicleDebuggingEnabled { get; private set; }
+    public static bool VehicleEnableLinearDeflection { get; private set; }
+    public static bool VehicleLinearDeflectionNotCollidingNoZ { get; private set; }
+    public static bool VehicleEnableAngularVerticalAttraction { get; private set; }
+    public static int VehicleAngularVerticalAttractionAlgorithm { get; private set; }
+    public static bool VehicleEnableAngularDeflection { get; private set; }
+    public static bool VehicleEnableAngularBanking { get; private set; }
 
     // Convex Hulls
     public static int CSHullMaxDepthSplit { get; private set; }
@@ -149,9 +171,19 @@ public static class BSParam
     public static float CSHullVolumeConservationThresholdPercent { get; private set; }
     public static int CSHullMaxVertices { get; private set; }
     public static float CSHullMaxSkinWidth { get; private set; }
+        public static float BHullMaxVerticesPerHull { get; private set; }               // 100
+        public static float BHullMinClusters { get; private set; }                              // 2
+        public static float BHullCompacityWeight { get; private set; }                  // 0.1
+        public static float BHullVolumeWeight { get; private set; }                             // 0.0
+        public static float BHullConcavity { get; private set; }                                    // 100
+        public static bool BHullAddExtraDistPoints { get; private set; }                // false
+        public static bool BHullAddNeighboursDistPoints { get; private set; }   // false
+        public static bool BHullAddFacesPoints { get; private set; }                    // false
+        public static bool BHullShouldAdjustCollisionMargin { get; private set; }       // false
 
     // Linkset implementation parameters
     public static float LinksetImplementation { get; private set; }
+    public static bool LinksetOffsetCenterOfMass { get; private set; }
     public static bool LinkConstraintUseFrameOffset { get; private set; }
     public static bool LinkConstraintEnableTransMotor { get; private set; }
     public static float LinkConstraintTransMotorMaxVel { get; private set; }
@@ -223,16 +255,41 @@ public static class BSParam
             getter = pGetter;
             objectSet = pObjSetter;
         }
-        /* Wish I could simplify using this definition but CLR doesn't store references so closure around delegates of references won't work
-        public ParameterDefn(string pName, string pDesc, T pDefault, ref T loc)
+        // Simple parameter variable where property name is the same as the INI file name
+        //     and the value is only a simple get and set.
+        public ParameterDefn(string pName, string pDesc, T pDefault)
             : base(pName, pDesc)
         {
             defaultValue = pDefault;
-            setter = (s, v) => { loc = v; };
-            getter = (s) => { return loc; };
+            setter = (s, v) => { SetValueByName(s, name, v); };
+            getter = (s) => { return GetValueByName(s, name); };
             objectSet = null;
         }
-         */
+        // Use reflection to find the property named 'pName' in BSParam and assign 'val' to same.
+        private void SetValueByName(BSScene s, string pName, T val)
+        {
+            PropertyInfo prop = typeof(BSParam).GetProperty(pName, BindingFlags.Public | BindingFlags.Static | BindingFlags.FlattenHierarchy);
+            if (prop == null)
+            {
+                // This should only be output when someone adds a new INI parameter and misspells the name.
+                s.Logger.ErrorFormat("{0} SetValueByName: did not find '{1}'. Verify specified property name is the same as the given INI parameters name.", LogHeader, pName);
+            }
+            else
+            {
+                prop.SetValue(null, val, null);
+            }
+        }
+        // Use reflection to find the property named 'pName' in BSParam and return the value in same.
+        private T GetValueByName(BSScene s, string pName)
+        {
+            PropertyInfo prop = typeof(BSParam).GetProperty(pName, BindingFlags.Public | BindingFlags.Static | BindingFlags.FlattenHierarchy);
+            if (prop == null)
+            {
+                // This should only be output when someone adds a new INI parameter and misspells the name.
+                s.Logger.ErrorFormat("{0} GetValueByName: did not find '{1}'. Verify specified property name is the same as the given INI parameter name.", LogHeader, pName);
+            }
+            return (T)prop.GetValue(null, null);
+        }
         public override void AssignDefault(BSScene s)
         {
             setter(s, defaultValue);
@@ -309,6 +366,11 @@ public static class BSParam
     //    v = value (appropriate type)
     private static ParameterDefnBase[] ParameterDefinitions =
     {
+        new ParameterDefn<bool>("UseSeparatePhysicsThread", "If 'true', the physics engine runs independent from the simulator heartbeat",
+            false ),
+        new ParameterDefn<float>("PhysicsTimeStep", "If separate thread, seconds to simulate each interval",
+            0.089f ),
+
         new ParameterDefn<bool>("MeshSculptedPrim", "Whether to create meshes for sculpties",
             true,
             (s) => { return ShouldMeshSculptedPrim; },
@@ -322,18 +384,20 @@ public static class BSParam
             (s) => { return ShouldUseHullsForPhysicalObjects; },
             (s,v) => { ShouldUseHullsForPhysicalObjects = v; } ),
         new ParameterDefn<bool>("ShouldRemoveZeroWidthTriangles", "If true, remove degenerate triangles from meshes",
-            true,
-            (s) => { return ShouldRemoveZeroWidthTriangles; },
-            (s,v) => { ShouldRemoveZeroWidthTriangles = v; } ),
+            true ),
+        new ParameterDefn<bool>("ShouldUseBulletHACD", "If true, use the Bullet version of HACD",
+            false ),
+        new ParameterDefn<bool>("ShouldUseSingleConvexHullForPrims", "If true, use a single convex hull shape for physical prims",
+            true ),
+        new ParameterDefn<bool>("ShouldUseGImpactShapeForPrims", "If true, use a GImpact shape for prims with cuts and twists",
+            false ),
+        new ParameterDefn<bool>("ShouldUseAssetHulls", "If true, use hull if specified in the mesh asset info",
+            true ),
 
         new ParameterDefn<int>("CrossingFailuresBeforeOutOfBounds", "How forgiving we are about getting into adjactent regions",
-            5,
-            (s) => { return CrossingFailuresBeforeOutOfBounds; },
-            (s,v) => { CrossingFailuresBeforeOutOfBounds = v; } ),
+            5 ),
         new ParameterDefn<float>("UpdateVelocityChangeThreshold", "Change in updated velocity required before reporting change to simulator",
-            0.1f,
-            (s) => { return UpdateVelocityChangeThreshold; },
-            (s,v) => { UpdateVelocityChangeThreshold = v; } ),
+            0.1f ),
 
         new ParameterDefn<float>("MeshLevelOfDetail", "Level of detail to render meshes (32, 16, 8 or 4. 32=most detailed)",
             32f,
@@ -399,26 +463,22 @@ 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,
-            (s) => { return DensityScaleFactor; },
-            (s,v) => { DensityScaleFactor = v; } ),
+            0.01f ),
 
         new ParameterDefn<float>("PID_D", "Derivitive factor for motion smoothing",
-            2200f,
-            (s) => { return (float)PID_D; },
-            (s,v) => { PID_D = v; } ),
+            2200f ),
         new ParameterDefn<float>("PID_P", "Parameteric factor for motion smoothing",
-            900f,
-            (s) => { return (float)PID_P; },
-            (s,v) => { PID_P = v; } ),
+            900f ),
 
         new ParameterDefn<float>("DefaultFriction", "Friction factor used on new objects",
             0.2f,
             (s) => { return DefaultFriction; },
             (s,v) => { DefaultFriction = v; s.UnmanagedParams[0].defaultFriction = v; } ),
+        // For historical reasons, the viewer and simulator multiply the density by 100
         new ParameterDefn<float>("DefaultDensity", "Density for new objects" ,
-            10.000006836f,  // Aluminum g/cm3
+            1000.0006836f,  // Aluminum g/cm3 * 100
             (s) => { return DefaultDensity; },
             (s,v) => { DefaultDensity = v; s.UnmanagedParams[0].defaultDensity = v; } ),
         new ParameterDefn<float>("DefaultRestitution", "Bouncyness of an object" ,
@@ -478,86 +538,61 @@ public static class BSParam
             (s,o) => { s.PE.SetContactProcessingThreshold(o.PhysBody, ContactProcessingThreshold); } ),
 
             new ParameterDefn<float>("TerrainImplementation", "Type of shape to use for terrain (0=heightmap, 1=mesh)",
-            (float)BSTerrainPhys.TerrainImplementation.Mesh,
-            (s) => { return TerrainImplementation; },
-            (s,v) => { TerrainImplementation = v; } ),
+            (float)BSTerrainPhys.TerrainImplementation.Mesh ),
         new ParameterDefn<int>("TerrainMeshMagnification", "Number of times the 256x256 heightmap is multiplied to create the terrain mesh" ,
-            2,
-            (s) => { return TerrainMeshMagnification; },
-            (s,v) => { TerrainMeshMagnification = v; } ),
+            2 ),
         new ParameterDefn<float>("TerrainFriction", "Factor to reduce movement against terrain surface" ,
-            0.3f,
-            (s) => { return TerrainFriction; },
-            (s,v) => { TerrainFriction = v;  /* TODO: set on real terrain */} ),
+            0.3f ),
         new ParameterDefn<float>("TerrainHitFraction", "Distance to measure hit collisions" ,
-            0.8f,
-            (s) => { return TerrainHitFraction; },
-            (s,v) => { TerrainHitFraction = v; /* TODO: set on real terrain */ } ),
+            0.8f ),
         new ParameterDefn<float>("TerrainRestitution", "Bouncyness" ,
-            0f,
-            (s) => { return TerrainRestitution; },
-            (s,v) => { TerrainRestitution = v;  /* TODO: set on real terrain */ } ),
+            0f ),
         new ParameterDefn<float>("TerrainContactProcessingThreshold", "Distance from terrain to stop processing collisions" ,
-            0.0f,
-            (s) => { return TerrainContactProcessingThreshold; },
-            (s,v) => { TerrainContactProcessingThreshold = v;  /* TODO: set on real terrain */ } ),
+            0.0f ),
         new ParameterDefn<float>("TerrainCollisionMargin", "Margin where collision checking starts" ,
-            0.08f,
-            (s) => { return TerrainCollisionMargin; },
-            (s,v) => { TerrainCollisionMargin = v;  /* TODO: set on real terrain */ } ),
+            0.08f ),
 
         new ParameterDefn<float>("AvatarFriction", "Factor to reduce movement against an avatar. Changed on avatar recreation.",
-            0.2f,
-            (s) => { return AvatarFriction; },
-            (s,v) => { AvatarFriction = v; } ),
+            0.2f ),
         new ParameterDefn<float>("AvatarStandingFriction", "Avatar friction when standing. Changed on avatar recreation.",
-            0.95f,
-            (s) => { return AvatarStandingFriction; },
-            (s,v) => { AvatarStandingFriction = v; } ),
+            0.95f ),
         new ParameterDefn<float>("AvatarAlwaysRunFactor", "Speed multiplier if avatar is set to always run",
-            1.3f,
-            (s) => { return AvatarAlwaysRunFactor; },
-            (s,v) => { AvatarAlwaysRunFactor = v; } ),
-        new ParameterDefn<float>("AvatarDensity", "Density of an avatar. Changed on avatar recreation.",
-            3.5f,
-            (s) => { return AvatarDensity; },
-            (s,v) => { AvatarDensity = v; } ),
+            1.3f ),
+            // For historical reasons, density is reported  * 100
+        new ParameterDefn<float>("AvatarDensity", "Density of an avatar. Changed on avatar recreation. Scaled times 100.",
+            3500f) ,    // 3.5 * 100
         new ParameterDefn<float>("AvatarRestitution", "Bouncyness. Changed on avatar recreation.",
-            0f,
-            (s) => { return AvatarRestitution; },
-            (s,v) => { AvatarRestitution = v; } ),
+            0f ),
         new ParameterDefn<float>("AvatarCapsuleWidth", "The distance between the sides of the avatar capsule",
-            0.6f,
-            (s) => { return AvatarCapsuleWidth; },
-            (s,v) => { AvatarCapsuleWidth = v; } ),
+            0.6f ) ,
         new ParameterDefn<float>("AvatarCapsuleDepth", "The distance between the front and back of the avatar capsule",
-            0.45f,
-            (s) => { return AvatarCapsuleDepth; },
-            (s,v) => { AvatarCapsuleDepth = v; } ),
+            0.45f ),
         new ParameterDefn<float>("AvatarCapsuleHeight", "Default height of space around avatar",
-            1.5f,
-            (s) => { return AvatarCapsuleHeight; },
-            (s,v) => { AvatarCapsuleHeight = v; } ),
+            1.5f ),
+        new ParameterDefn<float>("AvatarHeightLowFudge", "A fudge factor to make small avatars stand on the ground",
+            -0.2f ),
+        new ParameterDefn<float>("AvatarHeightMidFudge", "A fudge distance to adjust average sized avatars to be standing on ground",
+            0.1f ),
+        new ParameterDefn<float>("AvatarHeightHighFudge", "A fudge factor to make tall avatars stand on the ground",
+            0.1f ),
             new ParameterDefn<float>("AvatarContactProcessingThreshold", "Distance from capsule to check for collisions",
-            0.1f,
-            (s) => { return AvatarContactProcessingThreshold; },
-            (s,v) => { AvatarContactProcessingThreshold = v; } ),
+            0.1f ),
+            new ParameterDefn<float>("AvatarStopZeroThreshold", "Movement velocity below which avatar is assumed to be stopped",
+            0.1f ),
             new ParameterDefn<float>("AvatarBelowGroundUpCorrectionMeters", "Meters to move avatar up if it seems to be below ground",
-            1.0f,
-            (s) => { return AvatarBelowGroundUpCorrectionMeters; },
-            (s,v) => { AvatarBelowGroundUpCorrectionMeters = v; } ),
+            1.0f ),
+            new ParameterDefn<int>("AvatarJumpFrames", "Number of frames to allow jump forces. Changes jump height.",
+            4 ),
             new ParameterDefn<float>("AvatarStepHeight", "Height of a step obstacle to consider step correction",
-            0.3f,
-            (s) => { return AvatarStepHeight; },
-            (s,v) => { AvatarStepHeight = v; } ),
+            0.6f ) ,
             new ParameterDefn<float>("AvatarStepApproachFactor", "Factor to control angle of approach to step (0=straight on)",
-            0.6f,
-            (s) => { return AvatarStepApproachFactor; },
-            (s,v) => { AvatarStepApproachFactor = v; } ),
+            0.6f ),
             new ParameterDefn<float>("AvatarStepForceFactor", "Controls the amount of force up applied to step up onto a step",
-            2.0f,
-            (s) => { return AvatarStepForceFactor; },
-            (s,v) => { AvatarStepForceFactor = v; } ),
+            1.0f ),
+            new ParameterDefn<float>("AvatarStepUpCorrectionFactor", "Multiplied by height of step collision to create up movement at step",
+            1.0f ),
+            new ParameterDefn<int>("AvatarStepSmoothingSteps", "Number of frames after a step collision that we continue walking up stairs",
+            2 ),
 
         new ParameterDefn<float>("VehicleMaxLinearVelocity", "Maximum velocity magnitude that can be assigned to a vehicle",
             1000.0f,
@@ -568,37 +603,33 @@ public static class BSParam
             (s) => { return (float)VehicleMaxAngularVelocity; },
             (s,v) => { VehicleMaxAngularVelocity = v; VehicleMaxAngularVelocitySq = v * v; } ),
         new ParameterDefn<float>("VehicleAngularDamping", "Factor to damp vehicle angular movement per second (0.0 - 1.0)",
-            0.0f,
-            (s) => { return VehicleAngularDamping; },
-            (s,v) => { VehicleAngularDamping = v; } ),
+            0.0f ),
         new ParameterDefn<Vector3>("VehicleLinearFactor", "Fraction of physical linear changes applied to vehicle (<0,0,0> to <1,1,1>)",
-            new Vector3(1f, 1f, 1f),
-            (s) => { return VehicleLinearFactor; },
-            (s,v) => { VehicleLinearFactor = v; } ),
+            new Vector3(1f, 1f, 1f) ),
         new ParameterDefn<Vector3>("VehicleAngularFactor", "Fraction of physical angular changes applied to vehicle (<0,0,0> to <1,1,1>)",
-            new Vector3(1f, 1f, 1f),
-            (s) => { return VehicleAngularFactor; },
-            (s,v) => { VehicleAngularFactor = v; } ),
+            new Vector3(1f, 1f, 1f) ),
+        new ParameterDefn<Vector3>("VehicleInertiaFactor", "Fraction of physical inertia applied (<0,0,0> to <1,1,1>)",
+            new Vector3(1f, 1f, 1f) ),
         new ParameterDefn<float>("VehicleFriction", "Friction of vehicle on the ground (0.0 - 1.0)",
-            0.0f,
-            (s) => { return VehicleFriction; },
-            (s,v) => { VehicleFriction = v; } ),
+            0.0f ),
         new ParameterDefn<float>("VehicleRestitution", "Bouncyness factor for vehicles (0.0 - 1.0)",
-            0.0f,
-            (s) => { return VehicleRestitution; },
-            (s,v) => { VehicleRestitution = v; } ),
+            0.0f ),
         new ParameterDefn<float>("VehicleGroundGravityFudge", "Factor to multiply gravity if a ground vehicle is probably on the ground (0.0 - 1.0)",
-            0.2f,
-            (s) => { return VehicleGroundGravityFudge; },
-            (s,v) => { VehicleGroundGravityFudge = v; } ),
+            0.2f ),
         new ParameterDefn<float>("VehicleAngularBankingTimescaleFudge", "Factor to multiple angular banking timescale. Tune to increase realism.",
-            60.0f,
-            (s) => { return VehicleAngularBankingTimescaleFudge; },
-            (s,v) => { VehicleAngularBankingTimescaleFudge = v; } ),
-        new ParameterDefn<bool>("VehicleDebuggingEnable", "Turn on/off vehicle debugging",
-            false,
-            (s) => { return VehicleDebuggingEnabled; },
-            (s,v) => { VehicleDebuggingEnabled = v; } ),
+            60.0f ),
+        new ParameterDefn<bool>("VehicleEnableLinearDeflection", "Turn on/off vehicle linear deflection effect",
+            true ),
+        new ParameterDefn<bool>("VehicleLinearDeflectionNotCollidingNoZ", "Turn on/off linear deflection Z effect on non-colliding vehicles",
+            true ),
+        new ParameterDefn<bool>("VehicleEnableAngularVerticalAttraction", "Turn on/off vehicle angular vertical attraction effect",
+            true ),
+        new ParameterDefn<int>("VehicleAngularVerticalAttractionAlgorithm", "Select vertical attraction algo. You need to look at the source.",
+            0 ),
+        new ParameterDefn<bool>("VehicleEnableAngularDeflection", "Turn on/off vehicle angular deflection effect",
+            true ),
+        new ParameterDefn<bool>("VehicleEnableAngularBanking", "Turn on/off vehicle angular banking effect",
+            true ),
 
             new ParameterDefn<float>("MaxPersistantManifoldPoolSize", "Number of manifolds pooled (0 means default of 4096)",
             0f,
@@ -611,7 +642,7 @@ public static class BSParam
             new ParameterDefn<bool>("ShouldDisableContactPoolDynamicAllocation", "Enable to allow large changes in object count",
             false,
             (s) => { return ShouldDisableContactPoolDynamicAllocation; },
-            (s,v) => { ShouldDisableContactPoolDynamicAllocation = v; 
+            (s,v) => { ShouldDisableContactPoolDynamicAllocation = v;
                         s.UnmanagedParams[0].shouldDisableContactPoolDynamicAllocation = NumericBool(v); } ),
             new ParameterDefn<bool>("ShouldForceUpdateAllAabbs", "Enable to recomputer AABBs every simulator step",
             false,
@@ -641,64 +672,61 @@ public static class BSParam
             0f,
             (s) => { return GlobalContactBreakingThreshold; },
             (s,v) => { GlobalContactBreakingThreshold = v; s.UnmanagedParams[0].globalContactBreakingThreshold = v; } ),
+            new ParameterDefn<float>("PhysicsUnmanLoggingFrames", "If non-zero, frames between output of detailed unmanaged physics statistics",
+            0f,
+            (s) => { return PhysicsUnmanLoggingFrames; },
+            (s,v) => { PhysicsUnmanLoggingFrames = v; s.UnmanagedParams[0].physicsLoggingFrames = v; } ),
 
             new ParameterDefn<int>("CSHullMaxDepthSplit", "CS impl: max depth to split for hull. 1-10 but > 7 is iffy",
-            7,
-            (s) => { return CSHullMaxDepthSplit; },
-            (s,v) => { CSHullMaxDepthSplit = v; } ),
+            7 ),
             new ParameterDefn<int>("CSHullMaxDepthSplitForSimpleShapes", "CS impl: max depth setting for simple prim shapes",
-            2,
-            (s) => { return CSHullMaxDepthSplitForSimpleShapes; },
-            (s,v) => { CSHullMaxDepthSplitForSimpleShapes = v; } ),
+            2 ),
             new ParameterDefn<float>("CSHullConcavityThresholdPercent", "CS impl: concavity threshold percent (0-20)",
-            5f,
-            (s) => { return CSHullConcavityThresholdPercent; },
-            (s,v) => { CSHullConcavityThresholdPercent = v; } ),
+            5f ),
             new ParameterDefn<float>("CSHullVolumeConservationThresholdPercent", "percent volume conservation to collapse hulls (0-30)",
-            5f,
-            (s) => { return CSHullVolumeConservationThresholdPercent; },
-            (s,v) => { CSHullVolumeConservationThresholdPercent = v; } ),
+            5f ),
             new ParameterDefn<int>("CSHullMaxVertices", "CS impl: maximum number of vertices in output hulls. Keep < 50.",
-            32,
-            (s) => { return CSHullMaxVertices; },
-            (s,v) => { CSHullMaxVertices = v; } ),
+            32 ),
             new ParameterDefn<float>("CSHullMaxSkinWidth", "CS impl: skin width to apply to output hulls.",
-            0,
-            (s) => { return CSHullMaxSkinWidth; },
-            (s,v) => { CSHullMaxSkinWidth = v; } ),
+            0f ),
+
+            new ParameterDefn<float>("BHullMaxVerticesPerHull", "Bullet impl: max number of vertices per created hull",
+            200f ),
+            new ParameterDefn<float>("BHullMinClusters", "Bullet impl: minimum number of hulls to create per mesh",
+            10f ),
+            new ParameterDefn<float>("BHullCompacityWeight", "Bullet impl: weight factor for how compact to make hulls",
+            20f ),
+            new ParameterDefn<float>("BHullVolumeWeight", "Bullet impl: weight factor for volume in created hull",
+            0.1f ),
+            new ParameterDefn<float>("BHullConcavity", "Bullet impl: weight factor for how convex a created hull can be",
+            10f ),
+            new ParameterDefn<bool>("BHullAddExtraDistPoints", "Bullet impl: whether to add extra vertices for long distance vectors",
+            true ),
+            new ParameterDefn<bool>("BHullAddNeighboursDistPoints", "Bullet impl: whether to add extra vertices between neighbor hulls",
+            true ),
+            new ParameterDefn<bool>("BHullAddFacesPoints", "Bullet impl: whether to add extra vertices to break up hull faces",
+            true ),
+            new ParameterDefn<bool>("BHullShouldAdjustCollisionMargin", "Bullet impl: whether to shrink resulting hulls to account for collision margin",
+            false ),
 
             new ParameterDefn<float>("LinksetImplementation", "Type of linkset implementation (0=Constraint, 1=Compound, 2=Manual)",
-            (float)BSLinkset.LinksetImplementation.Compound,
-            (s) => { return LinksetImplementation; },
-            (s,v) => { LinksetImplementation = v; } ),
+            (float)BSLinkset.LinksetImplementation.Compound ),
+            new ParameterDefn<bool>("LinksetOffsetCenterOfMass", "If 'true', compute linkset center-of-mass and offset linkset position to account for same",
+            true ),
             new ParameterDefn<bool>("LinkConstraintUseFrameOffset", "For linksets built with constraints, enable frame offsetFor linksets built with constraints, enable frame offset.",
-            false,
-            (s) => { return LinkConstraintUseFrameOffset; },
-            (s,v) => { LinkConstraintUseFrameOffset = v; } ),
+            false ),
             new ParameterDefn<bool>("LinkConstraintEnableTransMotor", "Whether to enable translational motor on linkset constraints",
-            true,
-            (s) => { return LinkConstraintEnableTransMotor; },
-            (s,v) => { LinkConstraintEnableTransMotor = v; } ),
+            true ),
             new ParameterDefn<float>("LinkConstraintTransMotorMaxVel", "Maximum velocity to be applied by translational motor in linkset constraints",
-            5.0f,
-            (s) => { return LinkConstraintTransMotorMaxVel; },
-            (s,v) => { LinkConstraintTransMotorMaxVel = v; } ),
+            5.0f ),
             new ParameterDefn<float>("LinkConstraintTransMotorMaxForce", "Maximum force to be applied by translational motor in linkset constraints",
-            0.1f,
-            (s) => { return LinkConstraintTransMotorMaxForce; },
-            (s,v) => { LinkConstraintTransMotorMaxForce = v; } ),
+            0.1f ),
             new ParameterDefn<float>("LinkConstraintCFM", "Amount constraint can be violated. 0=no violation, 1=infinite. Default=0.1",
-            0.1f,
-            (s) => { return LinkConstraintCFM; },
-            (s,v) => { LinkConstraintCFM = v; } ),
+            0.1f ),
             new ParameterDefn<float>("LinkConstraintERP", "Amount constraint is corrected each tick. 0=none, 1=all. Default = 0.2",
-            0.1f,
-            (s) => { return LinkConstraintERP; },
-            (s,v) => { LinkConstraintERP = v; } ),
+            0.1f ),
             new ParameterDefn<float>("LinkConstraintSolverIterations", "Number of solver iterations when computing constraint. (0 = Bullet default)",
-            40,
-            (s) => { return LinkConstraintSolverIterations; },
-            (s,v) => { LinkConstraintSolverIterations = v; } ),
+            40 ),
 
         new ParameterDefn<int>("PhysicsMetricFrames", "Frames between outputting detailed phys metrics. (0 is off)",
             0,
@@ -707,7 +735,7 @@ public static class BSParam
         new ParameterDefn<float>("ResetBroadphasePool", "Setting this is any value resets the broadphase collision pool",
             0f,
             (s) => { return 0f; },
-            (s,v) => { BSParam.ResetBroadphasePoolTainted(s, v); } ),
+            (s,v) => { BSParam.ResetBroadphasePoolTainted(s, v, false /* inTaintTime */); } ),
         new ParameterDefn<float>("ResetConstraintSolver", "Setting this is any value resets the constraint solver",
             0f,
             (s) => { return 0f; },
@@ -793,10 +821,10 @@ public static class BSParam
     // =====================================================================
     // There are parameters that, when set, cause things to happen in the physics engine.
     // This causes the broadphase collision cache to be cleared.
-    private static void ResetBroadphasePoolTainted(BSScene pPhysScene, float v)
+    private static void ResetBroadphasePoolTainted(BSScene pPhysScene, float v, bool inTaintTime)
     {
         BSScene physScene = pPhysScene;
-        physScene.TaintedObject("BSParam.ResetBroadphasePoolTainted", delegate()
+        physScene.TaintedObject(inTaintTime, "BSParam.ResetBroadphasePoolTainted", delegate()
         {
             physScene.PE.ResetBroadphasePool(physScene.World);
         });
@@ -806,7 +834,7 @@ public static class BSParam
     private static void ResetConstraintSolverTainted(BSScene pPhysScene, float v)
     {
         BSScene physScene = pPhysScene;
-        physScene.TaintedObject("BSParam.ResetConstraintSolver", delegate()
+        physScene.TaintedObject(BSScene.DetailLogZero, "BSParam.ResetConstraintSolver", delegate()
         {
             physScene.PE.ResetConstraintSolver(physScene.World);
         });
diff --git a/OpenSim/Region/Physics/BulletSPlugin/BSPhysObject.cs b/OpenSim/Region/Physics/BulletSPlugin/BSPhysObject.cs
index 6bb88c7..f89b376 100755
--- a/OpenSim/Region/Physics/BulletSPlugin/BSPhysObject.cs
+++ b/OpenSim/Region/Physics/BulletSPlugin/BSPhysObject.cs
@@ -38,12 +38,12 @@ namespace OpenSim.Region.Physics.BulletSPlugin
  * Class to wrap all objects.
  * The rest of BulletSim doesn't need to keep checking for avatars or prims
  *        unless the difference is significant.
- * 
+ *
  *  Variables in the physicsl objects are in three forms:
  *      VariableName: used by the simulator and performs taint operations, etc
  *      RawVariableName: direct reference to the BulletSim storage for the variable value
  *      ForceVariableName: direct reference (store and fetch) to the value in the physics engine.
- *  The last two (and certainly the last one) should be referenced only in taint-time.
+ *  The last one should only be referenced in taint-time.
  */
 
 /*
@@ -52,7 +52,7 @@ namespace OpenSim.Region.Physics.BulletSPlugin
  * SOP.ApplyImpulse     SOP.ApplyAngularImpulse     SOP.SetAngularImpulse   SOP.SetForce
  * SOG.ApplyImpulse     SOG.ApplyAngularImpulse     SOG.SetAngularImpulse
  * PA.AddForce          PA.AddAngularForce          PA.Torque = v           PA.Force = v
- * BS.ApplyCentralForce BS.ApplyTorque              
+ * BS.ApplyCentralForce BS.ApplyTorque
  */
 
 // Flags used to denote which properties updates when making UpdateProperties calls to linksets, etc.
@@ -72,19 +72,27 @@ public abstract class BSPhysObject : PhysicsActor
     }
     protected BSPhysObject(BSScene parentScene, uint localID, string name, string typeName)
     {
-        PhysicsScene = parentScene;
+        IsInitialized = false;
+
+        PhysScene = parentScene;
         LocalID = localID;
         PhysObjectName = name;
         Name = name;    // PhysicsActor also has the name of the object. Someday consolidate.
         TypeName = typeName;
 
+        // The collection of things that push me around
+        PhysicalActors = new BSActorCollection(PhysScene);
+
         // Initialize variables kept in base.
         GravModifier = 1.0f;
         Gravity = new OMV.Vector3(0f, 0f, BSParam.Gravity);
+        HoverActive = false;
 
         // We don't have any physical representation yet.
         PhysBody = new BulletBody(localID);
-        PhysShape = new BulletShape();
+        PhysShape = new BSShapeNull();
+
+        UserSetCenterOfMassDisplacement = null;
 
         PrimAssetState = PrimAssetCondition.Unknown;
 
@@ -92,30 +100,41 @@ public abstract class BSPhysObject : PhysicsActor
         SetMaterial((int)MaterialAttributes.Material.Wood);
 
         CollisionCollection = new CollisionEventUpdate();
-        CollisionsLastTick = CollisionCollection;
+        CollisionsLastReported = CollisionCollection;
+        CollisionsLastTick = new CollisionEventUpdate();
+        CollisionsLastTickStep = -1;
+
         SubscribedEventsMs = 0;
-        CollidingStep = 0;
-        CollidingGroundStep = 0;
-        CollisionAccumulation = 0;
+        // Crazy values that will never be true
+        CollidingStep = BSScene.NotASimulationStep;
+        CollidingGroundStep = BSScene.NotASimulationStep;
+        CollisionAccumulation = BSScene.NotASimulationStep;
         ColliderIsMoving = false;
         CollisionScore = 0;
 
         // All axis free.
-        LockedAxis = LockedAxisFree;
+        LockedLinearAxis = LockedAxisFree;
+        LockedAngularAxis = LockedAxisFree;
     }
 
     // Tell the object to clean up.
     public virtual void Destroy()
     {
-        UnRegisterAllPreStepActions();
-        UnRegisterAllPostStepActions();
+        PhysicalActors.Enable(false);
+        PhysScene.TaintedObject(LocalID, "BSPhysObject.Destroy", delegate()
+        {
+            PhysicalActors.Dispose();
+        });
     }
 
-    public BSScene PhysicsScene { get; protected set; }
+    public BSScene PhysScene { get; protected set; }
     // public override uint LocalID { get; set; } // Use the LocalID definition in PhysicsActor
     public string PhysObjectName { get; protected set; }
     public string TypeName { get; protected set; }
 
+    // Set to 'true' when the object is completely initialized.
+    // This mostly prevents property updates and collisions until the object is completely here.
+    public bool IsInitialized { get; protected set; }
 
     // Return the object mass without calculating it or having side effects
     public abstract float RawMass { get; }
@@ -131,26 +150,19 @@ public abstract class BSPhysObject : PhysicsActor
     // Reference to the physical body (btCollisionObject) of this object
     public BulletBody PhysBody;
     // Reference to the physical shape (btCollisionShape) of this object
-    public BulletShape PhysShape;
+    public BSShape PhysShape;
 
     // The physical representation of the prim might require an asset fetch.
     // The asset state is first 'Unknown' then 'Waiting' then either 'Failed' or 'Fetched'.
     public enum PrimAssetCondition
     {
-        Unknown, Waiting, Failed, Fetched
+        Unknown, Waiting, FailedAssetFetch, FailedMeshing, Fetched
     }
     public PrimAssetCondition PrimAssetState { get; set; }
 
     // The objects base shape information. Null if not a prim type shape.
     public PrimitiveBaseShape BaseShape { get; protected set; }
 
-    // Some types of objects have preferred physical representations.
-    // Returns SHAPE_UNKNOWN if there is no preference.
-    public virtual BSPhysicsShapeType PreferredPhysicalShape
-    {
-        get { return BSPhysicsShapeType.SHAPE_UNKNOWN; }
-    }
-
     // When the physical properties are updated, an EntityProperty holds the update values.
     // Keep the current and last EntityProperties to enable computation of differences
     //      between the current update and the previous values.
@@ -168,6 +180,7 @@ public abstract class BSPhysObject : PhysicsActor
     public abstract bool IsSolid { get; }
     public abstract bool IsStatic { get; }
     public abstract bool IsSelected { get; }
+    public abstract bool IsVolumeDetect { get; }
 
     // Materialness
     public MaterialAttributes.Material Material { get; private set; }
@@ -176,11 +189,25 @@ public abstract class BSPhysObject : PhysicsActor
         Material = (MaterialAttributes.Material)material;
 
         // Setting the material sets the material attributes also.
+        // TODO: decide if this is necessary -- the simulator does this.
         MaterialAttributes matAttrib = BSMaterials.GetAttributes(Material, false);
         Friction = matAttrib.friction;
         Restitution = matAttrib.restitution;
-        Density = matAttrib.density / BSParam.DensityScaleFactor;
-        DetailLog("{0},{1}.SetMaterial,Mat={2},frict={3},rest={4},den={5}", LocalID, TypeName, Material, Friction, Restitution, Density);
+        Density = matAttrib.density;
+        // DetailLog("{0},{1}.SetMaterial,Mat={2},frict={3},rest={4},den={5}", LocalID, TypeName, Material, Friction, Restitution, Density);
+    }
+
+    public override float Density
+    {
+        get
+        {
+            return base.Density;
+        }
+        set
+        {
+            DetailLog("{0},BSPhysObject.Density,set,den={1}", LocalID, value);
+            base.Density = value;
+        }
     }
 
     // Stop all physical motion.
@@ -190,21 +217,55 @@ public abstract class BSPhysObject : PhysicsActor
     // Update the physical location and motion of the object. Called with data from Bullet.
     public abstract void UpdateProperties(EntityProperties entprop);
 
-    public abstract OMV.Vector3 RawPosition { get; set; }
+    public virtual OMV.Vector3 RawPosition { get; set; }
     public abstract OMV.Vector3 ForcePosition { get; set; }
 
-    public abstract OMV.Quaternion RawOrientation { get; set; }
+    public virtual OMV.Quaternion RawOrientation { get; set; }
     public abstract OMV.Quaternion ForceOrientation { get; set; }
 
-    public abstract OMV.Vector3 RawVelocity { get; set; }
+    public OMV.Vector3 RawVelocity { get; set; }
     public abstract OMV.Vector3 ForceVelocity { get; set; }
 
+    public OMV.Vector3 RawForce { get; set; }
+    public OMV.Vector3 RawTorque { get; set; }
+    public override void AddAngularForce(OMV.Vector3 force, bool pushforce)
+    {
+        AddAngularForce(force, pushforce, false);
+    }
+    public abstract void AddAngularForce(OMV.Vector3 force, bool pushforce, bool inTaintTime);
+    public abstract void AddForce(OMV.Vector3 force, bool pushforce, bool inTaintTime);
+
     public abstract OMV.Vector3 ForceRotationalVelocity { get; set; }
 
     public abstract float ForceBuoyancy { get; set; }
 
     public virtual bool ForceBodyShapeRebuild(bool inTaintTime) { return false; }
 
+    public override bool PIDActive { set { MoveToTargetActive = value; } }
+    public override OMV.Vector3 PIDTarget { set { MoveToTargetTarget = value; } }
+    public override float PIDTau { set { MoveToTargetTau = value; } }
+
+    public bool MoveToTargetActive { get; set; }
+    public OMV.Vector3 MoveToTargetTarget { get; set; }
+    public float MoveToTargetTau { get; set; }
+
+    // Used for llSetHoverHeight and maybe vehicle height. Hover Height will override MoveTo target's Z
+    public override bool PIDHoverActive { set { HoverActive = value; } }
+    public override float PIDHoverHeight { set { HoverHeight = value; } }
+    public override PIDHoverType PIDHoverType { set { HoverType = value; } }
+    public override float PIDHoverTau { set { HoverTau = value; } }
+
+    public bool HoverActive { get; set; }
+    public float HoverHeight { get;  set; }
+    public PIDHoverType HoverType { get;  set; }
+    public float HoverTau { get; set; }
+
+    // For RotLookAt
+    public override OMV.Quaternion APIDTarget { set { return; } }
+    public override bool APIDActive { set { return; } }
+    public override float APIDStrength { set { return; } }
+    public override float APIDDamping { set { return; } }
+
     // The current velocity forward
     public virtual float ForwardSpeed
     {
@@ -226,10 +287,69 @@ public abstract class BSPhysObject : PhysicsActor
 
     // The user can optionally set the center of mass. The user's setting will override any
     //    computed center-of-mass (like in linksets).
-    public OMV.Vector3? UserSetCenterOfMass { get; set; }
+    // Note this is a displacement from the root's coordinates. Zero means use the root prim as center-of-mass.
+    public OMV.Vector3? UserSetCenterOfMassDisplacement { get; set; }
+
+    public OMV.Vector3 LockedLinearAxis { get; set; } // zero means locked. one means free.
+    public OMV.Vector3 LockedAngularAxis { get; set; } // zero means locked. one means free.
+    public const float FreeAxis = 1f;
+    public readonly OMV.Vector3 LockedAxisFree = new OMV.Vector3(FreeAxis, FreeAxis, FreeAxis);  // All axis are free
+
+    // Enable physical actions. Bullet will keep sleeping non-moving physical objects so
+    //     they need waking up when parameters are changed.
+    // Called in taint-time!!
+    public void ActivateIfPhysical(bool forceIt)
+    {
+        if (PhysBody.HasPhysicalBody)
+        {
+            if (IsPhysical)
+            {
+                // Physical objects might need activating
+                PhysScene.PE.Activate(PhysBody, forceIt);
+            }
+            else
+            {
+                // Clear the collision cache since we've changed some properties.
+                PhysScene.PE.ClearCollisionProxyCache(PhysScene.World, PhysBody);
+            }
+        }
+    }
 
-    public OMV.Vector3 LockedAxis { get; set; } // zero means locked. one means free.
-    public readonly OMV.Vector3 LockedAxisFree = new OMV.Vector3(1f, 1f, 1f);  // All axis are free
+    // 'actors' act on the physical object to change or constrain its motion. These can range from
+    //       hovering to complex vehicle motion.
+    // May be called at non-taint time as this just adds the actor to the action list and the real
+    //    work is done during the simulation step.
+    // Note that, if the actor is already in the list and we are disabling same, the actor is just left
+    //    in the list disabled.
+    public delegate BSActor CreateActor();
+    public void EnableActor(bool enableActor, string actorName, CreateActor creator)
+    {
+        lock (PhysicalActors)
+        {
+            BSActor theActor;
+            if (PhysicalActors.TryGetActor(actorName, out theActor))
+            {
+                // The actor already exists so just turn it on or off
+                DetailLog("{0},BSPhysObject.EnableActor,enablingExistingActor,name={1},enable={2}", LocalID, actorName, enableActor);
+                theActor.Enabled = enableActor;
+            }
+            else
+            {
+                // The actor does not exist. If it should, create it.
+                if (enableActor)
+                {
+                    DetailLog("{0},BSPhysObject.EnableActor,creatingActor,name={1}", LocalID, actorName);
+                    theActor = creator();
+                    PhysicalActors.Add(actorName, theActor);
+                    theActor.Enabled = true;
+                }
+                else
+                {
+                    DetailLog("{0},BSPhysObject.EnableActor,notCreatingActorSinceNotEnabled,name={1}", LocalID, actorName);
+                }
+            }
+        }
+    }
 
     #region Collisions
 
@@ -247,70 +367,98 @@ public abstract class BSPhysObject : PhysicsActor
     protected CollisionFlags CurrentCollisionFlags { get; set; }
     // On a collision, check the collider and remember if the last collider was moving
     //    Used to modify the standing of avatars (avatars on stationary things stand still)
-    protected bool ColliderIsMoving;
+    public bool ColliderIsMoving;
+    // 'true' if the last collider was a volume detect object
+    public bool ColliderIsVolumeDetect;
+    // Used by BSCharacter to manage standing (and not slipping)
+    public bool IsStationary;
 
     // Count of collisions for this object
     protected long CollisionAccumulation { get; set; }
 
     public override bool IsColliding {
-        get { return (CollidingStep == PhysicsScene.SimulationStep); }
+        get { return (CollidingStep == PhysScene.SimulationStep); }
         set {
             if (value)
-                CollidingStep = PhysicsScene.SimulationStep;
+                CollidingStep = PhysScene.SimulationStep;
             else
-                CollidingStep = 0;
+                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 == PhysicsScene.SimulationStep); }
+        get { return (CollidingGroundStep == PhysScene.SimulationStep); }
         set
         {
             if (value)
-                CollidingGroundStep = PhysicsScene.SimulationStep;
+                CollidingGroundStep = PhysScene.SimulationStep;
             else
-                CollidingGroundStep = 0;
+                CollidingGroundStep = BSScene.NotASimulationStep;
         }
     }
     public override bool CollidingObj {
-        get { return (CollidingObjectStep == PhysicsScene.SimulationStep); }
-        set { 
+        get { return (CollidingObjectStep == PhysScene.SimulationStep); }
+        set {
             if (value)
-                CollidingObjectStep = PhysicsScene.SimulationStep;
+                CollidingObjectStep = PhysScene.SimulationStep;
             else
-                CollidingObjectStep = 0;
+                CollidingObjectStep = BSScene.NotASimulationStep;
         }
     }
 
-    // The collisions that have been collected this tick
+    // The collisions that have been collected for the next collision reporting (throttled by subscription)
     protected CollisionEventUpdate CollisionCollection;
-    // Remember collisions from last tick for fancy collision based actions
+    // This is the collision collection last reported to the Simulator.
+    public CollisionEventUpdate CollisionsLastReported;
+    // Remember the collisions recorded in the last tick for fancy collision checking
     //     (like a BSCharacter walking up stairs).
-    protected CollisionEventUpdate CollisionsLastTick;
+    public CollisionEventUpdate CollisionsLastTick;
+    private long CollisionsLastTickStep = -1;
 
     // The simulation step is telling this object about a collision.
     // 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)
     {
         bool ret = false;
 
         // The following lines make IsColliding(), CollidingGround() and CollidingObj work
-        CollidingStep = PhysicsScene.SimulationStep;
-        if (collidingWith <= PhysicsScene.TerrainManager.HighestTerrainID)
+        CollidingStep = PhysScene.SimulationStep;
+        if (collidingWith <= PhysScene.TerrainManager.HighestTerrainID)
         {
-            CollidingGroundStep = PhysicsScene.SimulationStep;
+            CollidingGroundStep = PhysScene.SimulationStep;
         }
         else
         {
-            CollidingObjectStep = PhysicsScene.SimulationStep;
+            CollidingObjectStep = PhysScene.SimulationStep;
         }
 
         CollisionAccumulation++;
 
         // For movement tests, remember if we are colliding with an object that is moving.
         ColliderIsMoving = collidee != null ? (collidee.RawVelocity != OMV.Vector3.Zero) : false;
+        ColliderIsVolumeDetect = collidee != null ? (collidee.IsVolumeDetect) : false;
+
+        // Make a collection of the collisions that happened the last simulation tick.
+        // This is different than the collection created for sending up to the simulator as it is cleared every tick.
+        if (CollisionsLastTickStep != PhysScene.SimulationStep)
+        {
+            CollisionsLastTick = new CollisionEventUpdate();
+            CollisionsLastTickStep = PhysScene.SimulationStep;
+        }
+        CollisionsLastTick.AddCollider(collidingWith, new ContactPoint(contactPoint, contactNormal, pentrationDepth));
 
         // If someone has subscribed for collision events log the collision so it will be reported up
         if (SubscribedEvents()) {
@@ -332,12 +480,12 @@ public abstract class BSPhysObject : PhysicsActor
         bool ret = true;
 
         // If the 'no collision' call, force it to happen right now so quick collision_end
-        bool force = (CollisionCollection.Count == 0 && CollisionsLastTick.Count != 0);
+        bool force = (CollisionCollection.Count == 0 && CollisionsLastReported.Count != 0);
 
         // throttle the collisions to the number of milliseconds specified in the subscription
-        if (force || (PhysicsScene.SimulationNowTime >= NextCollisionOkTime))
+        if (force || (PhysScene.SimulationNowTime >= NextCollisionOkTime))
         {
-            NextCollisionOkTime = PhysicsScene.SimulationNowTime + SubscribedEventsMs;
+            NextCollisionOkTime = PhysScene.SimulationNowTime + SubscribedEventsMs;
 
             // We are called if we previously had collisions. If there are no collisions
             //   this time, send up one last empty event so OpenSim can sense collision end.
@@ -351,11 +499,11 @@ public abstract class BSPhysObject : PhysicsActor
             base.SendCollisionUpdate(CollisionCollection);
 
             // Remember the collisions from this tick for some collision specific processing.
-            CollisionsLastTick = CollisionCollection;
+            CollisionsLastReported = CollisionCollection;
 
             // The CollisionCollection instance is passed around in the simulator.
             // Make sure we don't have a handle to that one and that a new one is used for next time.
-            //    This fixes an interesting 'gotcha'. If we call CollisionCollection.Clear() here, 
+            //    This fixes an interesting 'gotcha'. If we call CollisionCollection.Clear() here,
             //    a race condition is created for the other users of this instance.
             CollisionCollection = new CollisionEventUpdate();
         }
@@ -372,10 +520,10 @@ public abstract class BSPhysObject : PhysicsActor
             // make sure first collision happens
             NextCollisionOkTime = Util.EnvironmentTickCountSubtract(SubscribedEventsMs);
 
-            PhysicsScene.TaintedObject(TypeName+".SubscribeEvents", delegate()
+            PhysScene.TaintedObject(LocalID, TypeName+".SubscribeEvents", delegate()
             {
                 if (PhysBody.HasPhysicalBody)
-                    CurrentCollisionFlags = PhysicsScene.PE.AddToCollisionFlags(PhysBody, CollisionFlags.BS_SUBSCRIBE_COLLISION_EVENTS);
+                    CurrentCollisionFlags = PhysScene.PE.AddToCollisionFlags(PhysBody, CollisionFlags.BS_SUBSCRIBE_COLLISION_EVENTS);
             });
         }
         else
@@ -387,11 +535,11 @@ public abstract class BSPhysObject : PhysicsActor
     public override void UnSubscribeEvents() {
         // DetailLog("{0},{1}.UnSubscribeEvents,unsubscribing", LocalID, TypeName);
         SubscribedEventsMs = 0;
-        PhysicsScene.TaintedObject(TypeName+".UnSubscribeEvents", delegate()
+        PhysScene.TaintedObject(LocalID, TypeName+".UnSubscribeEvents", delegate()
         {
             // Make sure there is a body there because sometimes destruction happens in an un-ideal order.
             if (PhysBody.HasPhysicalBody)
-                CurrentCollisionFlags = PhysicsScene.PE.RemoveFromCollisionFlags(PhysBody, CollisionFlags.BS_SUBSCRIBE_COLLISION_EVENTS);
+                CurrentCollisionFlags = PhysScene.PE.RemoveFromCollisionFlags(PhysBody, CollisionFlags.BS_SUBSCRIBE_COLLISION_EVENTS);
         });
     }
     // Return 'true' if the simulator wants collision events
@@ -405,7 +553,7 @@ public abstract class BSPhysObject : PhysicsActor
     {
         // Scale the collision count by the time since the last collision.
         // The "+1" prevents dividing by zero.
-        long timeAgo = PhysicsScene.SimulationStep - CollidingStep + 1;
+        long timeAgo = PhysScene.SimulationStep - CollidingStep + 1;
         CollisionScore = CollisionAccumulation / timeAgo;
     }
     public override float CollisionScore { get; set; }
@@ -413,103 +561,8 @@ public abstract class BSPhysObject : PhysicsActor
     #endregion // Collisions
 
     #region Per Simulation Step actions
-    // There are some actions that must be performed for a physical object before each simulation step.
-    // These actions are optional so, rather than scanning all the physical objects and asking them
-    //     if they have anything to do, a physical object registers for an event call before the step is performed.
-    // This bookkeeping makes it easy to add, remove and clean up after all these registrations.
-    private Dictionary<string, BSScene.PreStepAction> RegisteredPrestepActions = new Dictionary<string, BSScene.PreStepAction>();
-    private Dictionary<string, BSScene.PostStepAction> RegisteredPoststepActions = new Dictionary<string, BSScene.PostStepAction>();
-    protected void RegisterPreStepAction(string op, uint id, BSScene.PreStepAction actn)
-    {
-        string identifier = op + "-" + id.ToString();
 
-        lock (RegisteredPrestepActions)
-        {
-            // Clean out any existing action
-            UnRegisterPreStepAction(op, id);
-            RegisteredPrestepActions[identifier] = actn;
-            PhysicsScene.BeforeStep += actn;
-        }
-        DetailLog("{0},BSPhysObject.RegisterPreStepAction,id={1}", LocalID, identifier);
-    }
-
-    // Unregister a pre step action. Safe to call if the action has not been registered.
-    // Returns 'true' if an action was actually removed
-    protected bool UnRegisterPreStepAction(string op, uint id)
-    {
-        string identifier = op + "-" + id.ToString();
-        bool removed = false;
-        lock (RegisteredPrestepActions)
-        {
-            if (RegisteredPrestepActions.ContainsKey(identifier))
-            {
-                PhysicsScene.BeforeStep -= RegisteredPrestepActions[identifier];
-                RegisteredPrestepActions.Remove(identifier);
-                removed = true;
-            }
-        }
-        DetailLog("{0},BSPhysObject.UnRegisterPreStepAction,id={1},removed={2}", LocalID, identifier, removed);
-        return removed;
-    }
-
-    protected void UnRegisterAllPreStepActions()
-    {
-        lock (RegisteredPrestepActions)
-        {
-            foreach (KeyValuePair<string, BSScene.PreStepAction> kvp in RegisteredPrestepActions)
-            {
-                PhysicsScene.BeforeStep -= kvp.Value;
-            }
-            RegisteredPrestepActions.Clear();
-        }
-        DetailLog("{0},BSPhysObject.UnRegisterAllPreStepActions,", LocalID);
-    }
-    
-    protected void RegisterPostStepAction(string op, uint id, BSScene.PostStepAction actn)
-    {
-        string identifier = op + "-" + id.ToString();
-
-        lock (RegisteredPoststepActions)
-        {
-            // Clean out any existing action
-            UnRegisterPostStepAction(op, id);
-            RegisteredPoststepActions[identifier] = actn;
-            PhysicsScene.AfterStep += actn;
-        }
-        DetailLog("{0},BSPhysObject.RegisterPostStepAction,id={1}", LocalID, identifier);
-    }
-
-    // Unregister a pre step action. Safe to call if the action has not been registered.
-    // Returns 'true' if an action was actually removed.
-    protected bool UnRegisterPostStepAction(string op, uint id)
-    {
-        string identifier = op + "-" + id.ToString();
-        bool removed = false;
-        lock (RegisteredPoststepActions)
-        {
-            if (RegisteredPoststepActions.ContainsKey(identifier))
-            {
-                PhysicsScene.AfterStep -= RegisteredPoststepActions[identifier];
-                RegisteredPoststepActions.Remove(identifier);
-                removed = true;
-            }
-        }
-        DetailLog("{0},BSPhysObject.UnRegisterPostStepAction,id={1},removed={2}", LocalID, identifier, removed);
-        return removed;
-    }
-
-    protected void UnRegisterAllPostStepActions()
-    {
-        lock (RegisteredPoststepActions)
-        {
-            foreach (KeyValuePair<string, BSScene.PostStepAction> kvp in RegisteredPoststepActions)
-            {
-                PhysicsScene.AfterStep -= kvp.Value;
-            }
-            RegisteredPoststepActions.Clear();
-        }
-        DetailLog("{0},BSPhysObject.UnRegisterAllPostStepActions,", LocalID);
-    }
+    public BSActorCollection PhysicalActors;
 
     // When an update to the physical properties happens, this event is fired to let
     //    different actors to modify the update before it is passed around
@@ -522,53 +575,13 @@ public abstract class BSPhysObject : PhysicsActor
             actions(ref entprop);
     }
 
-    private Dictionary<string, PreUpdatePropertyAction> RegisteredPreUpdatePropertyActions = new Dictionary<string, PreUpdatePropertyAction>();
-    public void RegisterPreUpdatePropertyAction(string identifier, PreUpdatePropertyAction actn)
-    {
-        lock (RegisteredPreUpdatePropertyActions)
-        {
-            // Clean out any existing action
-            UnRegisterPreUpdatePropertyAction(identifier);
-            RegisteredPreUpdatePropertyActions[identifier] = actn;
-            OnPreUpdateProperty += actn;
-        }
-        DetailLog("{0},BSPhysObject.RegisterPreUpdatePropertyAction,id={1}", LocalID, identifier);
-    }
-    public bool UnRegisterPreUpdatePropertyAction(string identifier)
-    {
-        bool removed = false;
-        lock (RegisteredPreUpdatePropertyActions)
-        {
-            if (RegisteredPreUpdatePropertyActions.ContainsKey(identifier))
-            {
-                OnPreUpdateProperty -= RegisteredPreUpdatePropertyActions[identifier];
-                RegisteredPreUpdatePropertyActions.Remove(identifier);
-                removed = true;
-            }
-        }
-        DetailLog("{0},BSPhysObject.UnRegisterPreUpdatePropertyAction,id={1},removed={2}", LocalID, identifier, removed);
-        return removed;
-    }
-    public void UnRegisterAllPreUpdatePropertyActions()
-    {
-        lock (RegisteredPreUpdatePropertyActions)
-        {
-            foreach (KeyValuePair<string, PreUpdatePropertyAction> kvp in RegisteredPreUpdatePropertyActions)
-            {
-                OnPreUpdateProperty -= kvp.Value;
-            }
-            RegisteredPreUpdatePropertyActions.Clear();
-        }
-        DetailLog("{0},BSPhysObject.UnRegisterAllPreUpdatePropertyAction,", LocalID);
-    }
-
     #endregion // Per Simulation Step actions
 
     // High performance detailed logging routine used by the physical objects.
     protected void DetailLog(string msg, params Object[] args)
     {
-        if (PhysicsScene.PhysicsLogging.Enabled)
-            PhysicsScene.DetailLog(msg, args);
+        if (PhysScene.PhysicsLogging.Enabled)
+            PhysScene.DetailLog(msg, args);
     }
 
 }
diff --git a/OpenSim/Region/Physics/BulletSPlugin/BSPrim.cs b/OpenSim/Region/Physics/BulletSPlugin/BSPrim.cs
index 6a5461a..15b7090 100644
--- a/OpenSim/Region/Physics/BulletSPlugin/BSPrim.cs
+++ b/OpenSim/Region/Physics/BulletSPlugin/BSPrim.cs
@@ -41,7 +41,7 @@ namespace OpenSim.Region.Physics.BulletSPlugin
     [Serializable]
 public class BSPrim : BSPhysObject
 {
-    private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+    protected static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
     private static readonly string LogHeader = "[BULLETS PRIM]";
 
     // _size is what the user passed. Scale is what we pass to the physics engine with the mesh.
@@ -51,15 +51,8 @@ public class BSPrim : BSPhysObject
     private bool _isSelected;
     private bool _isVolumeDetect;
 
-    // _position is what the simulator thinks the positions of the prim is.
-    private OMV.Vector3 _position;
-
     private float _mass;    // the mass of this object
-    private OMV.Vector3 _force;
-    private OMV.Vector3 _velocity;
-    private OMV.Vector3 _torque;
     private OMV.Vector3 _acceleration;
-    private OMV.Quaternion _orientation;
     private int _physicsActorType;
     private bool _isPhysical;
     private bool _flying;
@@ -72,16 +65,18 @@ public class BSPrim : BSPhysObject
 
     private int CrossingFailures { get; set; }
 
-    public BSDynamics VehicleController { get; private set; }
-
-    private BSVMotor _targetMotor;
-    private OMV.Vector3 _PIDTarget;
-    private float _PIDTau;
+    // Keep a handle to the vehicle actor so it is easy to set parameters on same.
+    public const string VehicleActorName = "BasicVehicle";
 
-    private BSFMotor _hoverMotor;
-    private float _PIDHoverHeight;
-    private PIDHoverType _PIDHoverType;
-    private float _PIDHoverTau;
+    // Parameters for the hover actor
+    public const string HoverActorName = "BSPrim.HoverActor";
+    // Parameters for the axis lock actor
+    public const String LockedAxisActorName = "BSPrim.LockedAxis";
+    // Parameters for the move to target actor
+    public const string MoveToTargetActorName = "BSPrim.MoveToTargetActor";
+    // Parameters for the setForce and setTorque actors
+    public const string SetForceActorName = "BSPrim.SetForceActor";
+    public const string SetTorqueActorName = "BSPrim.SetTorqueActor";
 
     public BSPrim(uint localID, String primName, BSScene parent_scene, OMV.Vector3 pos, OMV.Vector3 size,
                        OMV.Quaternion rotation, PrimitiveBaseShape pbs, bool pisPhysical)
@@ -89,31 +84,34 @@ public class BSPrim : BSPhysObject
     {
         // m_log.DebugFormat("{0}: BSPrim creation of {1}, id={2}", LogHeader, primName, localID);
         _physicsActorType = (int)ActorTypes.Prim;
-        _position = pos;
+        RawPosition = pos;
         _size = size;
         Scale = size;   // prims are the size the user wants them to be (different for BSCharactes).
-        _orientation = rotation;
+        RawOrientation = rotation;
         _buoyancy = 0f;
-        _velocity = OMV.Vector3.Zero;
+        RawVelocity = OMV.Vector3.Zero;
         _rotationalVelocity = OMV.Vector3.Zero;
         BaseShape = pbs;
         _isPhysical = pisPhysical;
         _isVolumeDetect = false;
 
-        VehicleController = new BSDynamics(PhysicsScene, this);            // add vehicleness
+        // Add a dynamic vehicle to our set of actors that can move this prim.
+        // PhysicalActors.Add(VehicleActorName, new BSDynamics(PhysScene, this, VehicleActorName));
 
         _mass = CalculateMass();
 
-        DetailLog("{0},BSPrim.constructor,call", LocalID);
+        // DetailLog("{0},BSPrim.constructor,call", LocalID);
         // do the actual object creation at taint time
-        PhysicsScene.TaintedObject("BSPrim.create", delegate()
+        PhysScene.TaintedObject(LocalID, "BSPrim.create", delegate()
         {
             // Make sure the object is being created with some sanity.
             ExtremeSanityCheck(true /* inTaintTime */);
 
             CreateGeomAndObject(true);
 
-            CurrentCollisionFlags = PhysicsScene.PE.GetCollisionFlags(PhysBody);
+            CurrentCollisionFlags = PhysScene.PE.GetCollisionFlags(PhysBody);
+
+            IsInitialized = true;
         });
     }
 
@@ -121,19 +119,21 @@ public class BSPrim : BSPhysObject
     public override void Destroy()
     {
         // m_log.DebugFormat("{0}: Destroy, id={1}", LogHeader, LocalID);
+        IsInitialized = false;
+
         base.Destroy();
 
         // Undo any vehicle properties
         this.VehicleType = (int)Vehicle.TYPE_NONE;
 
-        PhysicsScene.TaintedObject("BSPrim.destroy", delegate()
+        PhysScene.TaintedObject(LocalID, "BSPrim.Destroy", delegate()
         {
             DetailLog("{0},BSPrim.Destroy,taint,", LocalID);
             // If there are physical body and shape, release my use of same.
-            PhysicsScene.Shapes.DereferenceBody(PhysBody, null);
+            PhysScene.Shapes.DereferenceBody(PhysBody, null);
             PhysBody.Clear();
-            PhysicsScene.Shapes.DereferenceShape(PhysShape, null);
-            PhysShape.Clear();
+            PhysShape.Dereference(PhysScene);
+            PhysShape = new BSShapeNull();
         });
     }
 
@@ -159,25 +159,13 @@ public class BSPrim : BSPhysObject
             ForceBodyShapeRebuild(false);
         }
     }
-    // 'unknown' says to choose the best type
-    public override BSPhysicsShapeType PreferredPhysicalShape
-        { get { return BSPhysicsShapeType.SHAPE_UNKNOWN; } }
-
     public override bool ForceBodyShapeRebuild(bool inTaintTime)
     {
-        if (inTaintTime)
+        PhysScene.TaintedObject(inTaintTime, LocalID, "BSPrim.ForceBodyShapeRebuild", delegate()
         {
             _mass = CalculateMass();   // changing the shape changes the mass
             CreateGeomAndObject(true);
-        }
-        else
-        {
-            PhysicsScene.TaintedObject("BSPrim.ForceBodyShapeRebuild", delegate()
-            {
-                _mass = CalculateMass();   // changing the shape changes the mass
-                CreateGeomAndObject(true);
-            });
-        }
+        });
         return true;
     }
     public override bool Grabbed {
@@ -190,7 +178,7 @@ public class BSPrim : BSPhysObject
             if (value != _isSelected)
             {
                 _isSelected = value;
-                PhysicsScene.TaintedObject("BSPrim.setSelected", delegate()
+                PhysScene.TaintedObject(LocalID, "BSPrim.setSelected", delegate()
                 {
                     DetailLog("{0},BSPrim.selected,taint,selected={1}", LocalID, _isSelected);
                     SetObjectDynamic(false);
@@ -231,165 +219,93 @@ public class BSPrim : BSPhysObject
     // Called at taint time!
     public override void ZeroMotion(bool inTaintTime)
     {
-        _velocity = OMV.Vector3.Zero;
+        RawVelocity = OMV.Vector3.Zero;
         _acceleration = OMV.Vector3.Zero;
         _rotationalVelocity = OMV.Vector3.Zero;
 
         // Zero some other properties in the physics engine
-        PhysicsScene.TaintedObject(inTaintTime, "BSPrim.ZeroMotion", delegate()
+        PhysScene.TaintedObject(inTaintTime, LocalID, "BSPrim.ZeroMotion", delegate()
         {
             if (PhysBody.HasPhysicalBody)
-                PhysicsScene.PE.ClearAllForces(PhysBody);
+                PhysScene.PE.ClearAllForces(PhysBody);
         });
     }
     public override void ZeroAngularMotion(bool inTaintTime)
     {
         _rotationalVelocity = OMV.Vector3.Zero;
         // Zero some other properties in the physics engine
-        PhysicsScene.TaintedObject(inTaintTime, "BSPrim.ZeroMotion", delegate()
+        PhysScene.TaintedObject(inTaintTime, LocalID, "BSPrim.ZeroMotion", delegate()
         {
             // DetailLog("{0},BSPrim.ZeroAngularMotion,call,rotVel={1}", LocalID, _rotationalVelocity);
             if (PhysBody.HasPhysicalBody)
             {
-                PhysicsScene.PE.SetInterpolationAngularVelocity(PhysBody, _rotationalVelocity);
-                PhysicsScene.PE.SetAngularVelocity(PhysBody, _rotationalVelocity);
+                PhysScene.PE.SetInterpolationAngularVelocity(PhysBody, _rotationalVelocity);
+                PhysScene.PE.SetAngularVelocity(PhysBody, _rotationalVelocity);
             }
         });
     }
 
-    bool TryExperimentalLockAxisCode = false;
-    BSConstraint LockAxisConstraint = null;
     public override void LockAngularMotion(OMV.Vector3 axis)
     {
         DetailLog("{0},BSPrim.LockAngularMotion,call,axis={1}", LocalID, axis);
 
         // "1" means free, "0" means locked
-        OMV.Vector3 locking = new OMV.Vector3(1f, 1f, 1f);
+        OMV.Vector3 locking = LockedAxisFree;
         if (axis.X != 1) locking.X = 0f;
         if (axis.Y != 1) locking.Y = 0f;
         if (axis.Z != 1) locking.Z = 0f;
-        LockedAxis = locking;
+        LockedAngularAxis = locking;
 
-        if (TryExperimentalLockAxisCode && LockedAxis != LockedAxisFree)
+        EnableActor(LockedAngularAxis != LockedAxisFree, LockedAxisActorName, delegate()
         {
-            // Lock that axis by creating a 6DOF constraint that has one end in the world and
-            //    the other in the object.
-            // http://www.bulletphysics.org/Bullet/phpBB3/viewtopic.php?p=20817
-            // http://www.bulletphysics.org/Bullet/phpBB3/viewtopic.php?p=26380
-
-            PhysicsScene.TaintedObject("BSPrim.LockAngularMotion", delegate()
-            {
-                CleanUpLockAxisPhysicals(true /* inTaintTime */);
-
-                BSConstraint6Dof axisConstrainer = new BSConstraint6Dof(PhysicsScene.World, PhysBody, 
-                                    OMV.Vector3.Zero, OMV.Quaternion.Inverse(RawOrientation),
-                                    true /* useLinearReferenceFrameB */, true /* disableCollisionsBetweenLinkedBodies */);
-                LockAxisConstraint = axisConstrainer;
-                PhysicsScene.Constraints.AddConstraint(LockAxisConstraint);
-
-                // The constraint is tied to the world and oriented to the prim.
-
-                // Free to move linearly
-                OMV.Vector3 linearLow = OMV.Vector3.Zero;
-                OMV.Vector3 linearHigh = PhysicsScene.TerrainManager.DefaultRegionSize;
-                axisConstrainer.SetLinearLimits(linearLow, linearHigh);
-
-                // Angular with some axis locked
-                float f2PI = (float)Math.PI * 2f;
-                OMV.Vector3 angularLow = new OMV.Vector3(-f2PI, -f2PI, -f2PI);
-                OMV.Vector3 angularHigh = new OMV.Vector3(f2PI, f2PI, f2PI);
-                if (LockedAxis.X != 1f)
-                {
-                    angularLow.X = 0f;
-                    angularHigh.X = 0f;
-                }
-                if (LockedAxis.Y != 1f)
-                {
-                    angularLow.Y = 0f;
-                    angularHigh.Y = 0f;
-                }
-                if (LockedAxis.Z != 1f)
-                {
-                    angularLow.Z = 0f;
-                    angularHigh.Z = 0f;
-                }
-                axisConstrainer.SetAngularLimits(angularLow, angularHigh);
-
-                DetailLog("{0},BSPrim.LockAngularMotion,create,linLow={1},linHi={2},angLow={3},angHi={4}",
-                                            LocalID, linearLow, linearHigh, angularLow, angularHigh);
-
-                // Constants from one of the posts mentioned above and used in Bullet's ConstraintDemo.
-                axisConstrainer.TranslationalLimitMotor(true /* enable */, 5.0f, 0.1f);
+            return new BSActorLockAxis(PhysScene, this, LockedAxisActorName);
+        });
 
-                axisConstrainer.RecomputeConstraintVariables(RawMass);
-            });
-        }
-        else
+        // Update parameters so the new actor's Refresh() action is called at the right time.
+        PhysScene.TaintedObject(LocalID, "BSPrim.LockAngularMotion", delegate()
         {
-            // Everything seems unlocked
-            CleanUpLockAxisPhysicals(false /* inTaintTime */);
-        }
+            UpdatePhysicalParameters();
+        });
 
         return;
     }
-    // Get rid of any constraint built for LockAxis
-    // Most often the constraint is removed when the constraint collection is cleaned for this prim.
-    private void CleanUpLockAxisPhysicals(bool inTaintTime)
-    {
-        if (LockAxisConstraint != null)
-        {
-            PhysicsScene.TaintedObject(inTaintTime, "BSPrim.CleanUpLockAxisPhysicals", delegate()
-            {
-                if (LockAxisConstraint != null)
-                {
-                    PhysicsScene.Constraints.RemoveAndDestroyConstraint(LockAxisConstraint);
-                    LockAxisConstraint = null;
-                    DetailLog("{0},BSPrim.CleanUpLockAxisPhysicals,destroyingConstraint", LocalID);
-                }
-            });
-        }
-    }
 
-    public override OMV.Vector3 RawPosition
-    {
-        get { return _position; }
-        set { _position = value; }
-    }
     public override OMV.Vector3 Position {
         get {
             // don't do the GetObjectPosition for root elements because this function is called a zillion times.
-            // _position = ForcePosition;
-            return _position;
+            // RawPosition = ForcePosition;
+            return RawPosition;
         }
         set {
             // If the position must be forced into the physics engine, use ForcePosition.
             // All positions are given in world positions.
-            if (_position == value)
+            if (RawPosition == value)
             {
-                DetailLog("{0},BSPrim.setPosition,call,positionNotChanging,pos={1},orient={2}", LocalID, _position, _orientation);
+                DetailLog("{0},BSPrim.setPosition,call,positionNotChanging,pos={1},orient={2}", LocalID, RawPosition, RawOrientation);
                 return;
             }
-            _position = value;
+            RawPosition = value;
             PositionSanityCheck(false);
 
-            PhysicsScene.TaintedObject("BSPrim.setPosition", delegate()
+            PhysScene.TaintedObject(LocalID, "BSPrim.setPosition", delegate()
             {
-                DetailLog("{0},BSPrim.SetPosition,taint,pos={1},orient={2}", LocalID, _position, _orientation);
-                ForcePosition = _position;
+                DetailLog("{0},BSPrim.SetPosition,taint,pos={1},orient={2}", LocalID, RawPosition, RawOrientation);
+                ForcePosition = RawPosition;
             });
         }
     }
 
+    // NOTE: overloaded by BSPrimDisplaced to handle offset for center-of-gravity.
     public override OMV.Vector3 ForcePosition {
         get {
-            _position = PhysicsScene.PE.GetPosition(PhysBody);
-            return _position;
+            RawPosition = PhysScene.PE.GetPosition(PhysBody);
+            return RawPosition;
         }
         set {
-            _position = value;
+            RawPosition = value;
             if (PhysBody.HasPhysicalBody)
             {
-                PhysicsScene.PE.SetTranslation(PhysBody, _position, _orientation);
+                PhysScene.PE.SetTranslation(PhysBody, RawPosition, RawOrientation);
                 ActivateIfPhysical(false);
             }
         }
@@ -406,7 +322,7 @@ public class BSPrim : BSPhysObject
         if (!IsPhysicallyActive)
             return ret;
 
-        if (!PhysicsScene.TerrainManager.IsWithinKnownTerrain(RawPosition))
+        if (!PhysScene.TerrainManager.IsWithinKnownTerrain(RawPosition))
         {
             // The physical object is out of the known/simulated area.
             // Upper levels of code will handle the transition to other areas so, for
@@ -414,7 +330,7 @@ public class BSPrim : BSPhysObject
             return ret;
         }
 
-        float terrainHeight = PhysicsScene.TerrainManager.GetTerrainHeightAtXYZ(RawPosition);
+        float terrainHeight = PhysScene.TerrainManager.GetTerrainHeightAtXYZ(RawPosition);
         OMV.Vector3 upForce = OMV.Vector3.Zero;
         float approxSize = Math.Max(Size.X, Math.Max(Size.Y, Size.Z));
         if ((RawPosition.Z + approxSize / 2f) < terrainHeight)
@@ -423,10 +339,10 @@ public class BSPrim : BSPhysObject
             float targetHeight = terrainHeight + (Size.Z / 2f);
             // If the object is below ground it just has to be moved up because pushing will
             //     not get it through the terrain
-            _position.Z = targetHeight;
+            RawPosition = new OMV.Vector3(RawPosition.X, RawPosition.Y, targetHeight);
             if (inTaintTime)
             {
-                ForcePosition = _position;
+                ForcePosition = RawPosition;
             }
             // If we are throwing the object around, zero its other forces
             ZeroMotion(inTaintTime);
@@ -435,7 +351,7 @@ public class BSPrim : BSPhysObject
 
         if ((CurrentCollisionFlags & CollisionFlags.BS_FLOATS_ON_WATER) != 0)
         {
-            float waterHeight = PhysicsScene.TerrainManager.GetWaterLevelAtXYZ(_position);
+            float waterHeight = PhysScene.TerrainManager.GetWaterLevelAtXYZ(RawPosition);
             // TODO: a floating motor so object will bob in the water
             if (Math.Abs(RawPosition.Z - waterHeight) > 0.1f)
             {
@@ -443,8 +359,8 @@ public class BSPrim : BSPhysObject
                 upForce.Z = (waterHeight - RawPosition.Z) * 1f;
 
                 // Apply upforce and overcome gravity.
-                OMV.Vector3 correctionForce = upForce - PhysicsScene.DefaultGravity;
-                DetailLog("{0},BSPrim.PositionSanityCheck,applyForce,pos={1},upForce={2},correctionForce={3}", LocalID, _position, upForce, correctionForce);
+                OMV.Vector3 correctionForce = upForce - PhysScene.DefaultGravity;
+                DetailLog("{0},BSPrim.PositionSanityCheck,applyForce,pos={1},upForce={2},correctionForce={3}", LocalID, RawPosition, upForce, correctionForce);
                 AddForce(correctionForce, false, inTaintTime);
                 ret = true;
             }
@@ -463,17 +379,17 @@ public class BSPrim : BSPhysObject
         uint wayOutThere = Constants.RegionSize * Constants.RegionSize;
         // There have been instances of objects getting thrown way out of bounds and crashing
         //    the border crossing code.
-        if (   _position.X < -Constants.RegionSize || _position.X > wayOutThere
-            || _position.Y < -Constants.RegionSize || _position.Y > wayOutThere
-            || _position.Z < -Constants.RegionSize || _position.Z > wayOutThere)
+        if (   RawPosition.X < -Constants.RegionSize || RawPosition.X > wayOutThere
+            || RawPosition.Y < -Constants.RegionSize || RawPosition.Y > wayOutThere
+            || RawPosition.Z < -Constants.RegionSize || RawPosition.Z > wayOutThere)
         {
-            _position = new OMV.Vector3(10, 10, 50);
+            RawPosition = new OMV.Vector3(10, 10, 50);
             ZeroMotion(inTaintTime);
             ret = true;
         }
-        if (_velocity.LengthSquared() > BSParam.MaxLinearVelocity)
+        if (RawVelocity.LengthSquared() > BSParam.MaxLinearVelocity)
         {
-            _velocity = Util.ClampV(_velocity, BSParam.MaxLinearVelocity);
+            RawVelocity = Util.ClampV(RawVelocity, BSParam.MaxLinearVelocity);
             ret = true;
         }
         if (_rotationalVelocity.LengthSquared() > BSParam.MaxAngularVelocitySquared)
@@ -498,7 +414,7 @@ public class BSPrim : BSPhysObject
         get { return _mass; }
     }
     // used when we only want this prim's mass and not the linkset thing
-    public override float RawMass { 
+    public override float RawMass {
         get { return _mass; }
     }
     // Set the physical mass to the passed mass.
@@ -509,10 +425,10 @@ public class BSPrim : BSPhysObject
         {
             if (IsStatic)
             {
-                PhysicsScene.PE.SetGravity(PhysBody, PhysicsScene.DefaultGravity);
+                PhysScene.PE.SetGravity(PhysBody, PhysScene.DefaultGravity);
                 Inertia = OMV.Vector3.Zero;
-                PhysicsScene.PE.SetMassProps(PhysBody, 0f, Inertia);
-                PhysicsScene.PE.UpdateInertiaTensor(PhysBody);
+                PhysScene.PE.SetMassProps(PhysBody, 0f, Inertia);
+                PhysScene.PE.UpdateInertiaTensor(PhysBody);
             }
             else
             {
@@ -521,16 +437,19 @@ public class BSPrim : BSPhysObject
                     // Changing interesting properties doesn't change proxy and collision cache
                     //    information. The Bullet solution is to re-add the object to the world
                     //    after parameters are changed.
-                    PhysicsScene.PE.RemoveObjectFromWorld(PhysicsScene.World, PhysBody);
+                    PhysScene.PE.RemoveObjectFromWorld(PhysScene.World, PhysBody);
                 }
 
                 // The computation of mass props requires gravity to be set on the object.
                 Gravity = ComputeGravity(Buoyancy);
-                PhysicsScene.PE.SetGravity(PhysBody, Gravity);
+                PhysScene.PE.SetGravity(PhysBody, Gravity);
 
-                Inertia = PhysicsScene.PE.CalculateLocalInertia(PhysShape, physMass);
-                PhysicsScene.PE.SetMassProps(PhysBody, physMass, Inertia);
-                PhysicsScene.PE.UpdateInertiaTensor(PhysBody);
+                // 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);
+                PhysScene.PE.UpdateInertiaTensor(PhysBody);
 
                 DetailLog("{0},BSPrim.UpdateMassProperties,mass={1},localInertia={2},grav={3},inWorld={4}",
                                             LocalID, physMass, Inertia, Gravity, inWorld);
@@ -546,7 +465,7 @@ public class BSPrim : BSPhysObject
     // Return what gravity should be set to this very moment
     public OMV.Vector3 ComputeGravity(float buoyancy)
     {
-        OMV.Vector3 ret = PhysicsScene.DefaultGravity;
+        OMV.Vector3 ret = PhysScene.DefaultGravity;
 
         if (!IsStatic)
         {
@@ -570,95 +489,121 @@ public class BSPrim : BSPhysObject
     }
 
     public override OMV.Vector3 Force {
-        get { return _force; }
+        get { return RawForce; }
         set {
-            _force = value;
-            if (_force != OMV.Vector3.Zero)
+            RawForce = value;
+            EnableActor(RawForce != OMV.Vector3.Zero, SetForceActorName, delegate()
             {
-                // If the force is non-zero, it must be reapplied each tick because
-                //    Bullet clears the forces applied last frame.
-                RegisterPreStepAction("BSPrim.setForce", LocalID,
-                    delegate(float timeStep)
-                    {
-                        if (!IsPhysicallyActive || _force == OMV.Vector3.Zero)
-                        {
-                            UnRegisterPreStepAction("BSPrim.setForce", LocalID);
-                            return;
-                        }
+                return new BSActorSetForce(PhysScene, this, SetForceActorName);
+            });
+        }
+    }
 
-                        DetailLog("{0},BSPrim.setForce,preStep,force={1}", LocalID, _force);
-                        if (PhysBody.HasPhysicalBody)
-                        {
-                            PhysicsScene.PE.ApplyCentralForce(PhysBody, _force);
-                            ActivateIfPhysical(false);
-                        }
-                    }
-                );
-            }
-            else
+    // 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;
+        if (PhysicalActors.TryGetActor(VehicleActorName, out actor))
+        {
+            ret = actor as BSDynamics;
+        }
+        else
+        {
+            if (createIfNone)
             {
-                UnRegisterPreStepAction("BSPrim.setForce", LocalID);
+                ret = new BSDynamics(PhysScene, this, VehicleActorName);
+                PhysicalActors.Add(ret.ActorName, ret);
             }
         }
+        return ret;
     }
 
     public override int VehicleType {
         get {
-            return (int)VehicleController.Type;   // if we are a vehicle, return that type
+            int ret = (int)Vehicle.TYPE_NONE;
+            BSDynamics vehicleActor = GetVehicleActor(false /* createIfNone */);
+            if (vehicleActor != null)
+                ret = (int)vehicleActor.Type;
+            return ret;
         }
         set {
             Vehicle type = (Vehicle)value;
 
-            PhysicsScene.TaintedObject("setVehicleType", delegate()
+            PhysScene.TaintedObject(LocalID, "setVehicleType", delegate()
             {
-                // Done at taint time so we're sure the physics engine is not using the variables
-                // Vehicle code changes the parameters for this vehicle type.
-                VehicleController.ProcessTypeChange(type);
-                ActivateIfPhysical(false);
-
-                // If an active vehicle, register the vehicle code to be called before each step
-                if (VehicleController.Type == Vehicle.TYPE_NONE)
+                // Some vehicle scripts change vehicle type on the fly as an easy way to
+                //    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 */);
+                if (type == Vehicle.TYPE_NONE)
                 {
-                    UnRegisterPreStepAction("BSPrim.Vehicle", LocalID);
-                    UnRegisterPostStepAction("BSPrim.Vehicle", LocalID);
+                    // 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
                 {
-                    RegisterPreStepAction("BSPrim.Vehicle", LocalID, VehicleController.Step);
-                    RegisterPostStepAction("BSPrim.Vehicle", LocalID, VehicleController.PostStep);
+                    // 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);
+                    }
                 }
             });
         }
     }
     public override void VehicleFloatParam(int param, float value)
     {
-        PhysicsScene.TaintedObject("BSPrim.VehicleFloatParam", delegate()
+        PhysScene.TaintedObject(LocalID, "BSPrim.VehicleFloatParam", delegate()
         {
-            VehicleController.ProcessFloatVehicleParam((Vehicle)param, value);
-            ActivateIfPhysical(false);
+            BSDynamics vehicleActor = GetVehicleActor(true /* createIfNone */);
+            if (vehicleActor != null)
+            {
+                vehicleActor.ProcessFloatVehicleParam((Vehicle)param, value);
+                ActivateIfPhysical(false);
+            }
         });
     }
     public override void VehicleVectorParam(int param, OMV.Vector3 value)
     {
-        PhysicsScene.TaintedObject("BSPrim.VehicleVectorParam", delegate()
+        PhysScene.TaintedObject(LocalID, "BSPrim.VehicleVectorParam", delegate()
         {
-            VehicleController.ProcessVectorVehicleParam((Vehicle)param, value);
-            ActivateIfPhysical(false);
+            BSDynamics vehicleActor = GetVehicleActor(true /* createIfNone */);
+            if (vehicleActor != null)
+            {
+                vehicleActor.ProcessVectorVehicleParam((Vehicle)param, value);
+                ActivateIfPhysical(false);
+            }
         });
     }
     public override void VehicleRotationParam(int param, OMV.Quaternion rotation)
     {
-        PhysicsScene.TaintedObject("BSPrim.VehicleRotationParam", delegate()
+        PhysScene.TaintedObject(LocalID, "BSPrim.VehicleRotationParam", delegate()
         {
-            VehicleController.ProcessRotationVehicleParam((Vehicle)param, rotation);
-            ActivateIfPhysical(false);
+            BSDynamics vehicleActor = GetVehicleActor(true /* createIfNone */);
+            if (vehicleActor != null)
+            {
+                vehicleActor.ProcessRotationVehicleParam((Vehicle)param, rotation);
+                ActivateIfPhysical(false);
+            }
         });
     }
     public override void VehicleFlags(int param, bool remove)
     {
-        PhysicsScene.TaintedObject("BSPrim.VehicleFlags", delegate()
+        PhysScene.TaintedObject(LocalID, "BSPrim.VehicleFlags", delegate()
         {
-            VehicleController.ProcessVehicleFlags(param, remove);
+            BSDynamics vehicleActor = GetVehicleActor(true /* createIfNone */);
+            if (vehicleActor != null)
+            {
+                vehicleActor.ProcessVehicleFlags(param, remove);
+            }
         });
     }
 
@@ -668,7 +613,7 @@ public class BSPrim : BSPhysObject
         if (_isVolumeDetect != newValue)
         {
             _isVolumeDetect = newValue;
-            PhysicsScene.TaintedObject("BSPrim.SetVolumeDetect", delegate()
+            PhysScene.TaintedObject(LocalID, "BSPrim.SetVolumeDetect", delegate()
             {
                 // DetailLog("{0},setVolumeDetect,taint,volDetect={1}", LocalID, _isVolumeDetect);
                 SetObjectDynamic(true);
@@ -676,10 +621,14 @@ public class BSPrim : BSPhysObject
         }
         return;
     }
+    public override bool IsVolumeDetect
+    {
+        get { return _isVolumeDetect; }
+    }
     public override void SetMaterial(int material)
     {
         base.SetMaterial(material);
-        PhysicsScene.TaintedObject("BSPrim.SetMaterial", delegate()
+        PhysScene.TaintedObject(LocalID, "BSPrim.SetMaterial", delegate()
         {
             UpdatePhysicalParameters();
         });
@@ -692,7 +641,7 @@ public class BSPrim : BSPhysObject
             if (base.Friction != value)
             {
                 base.Friction = value;
-                PhysicsScene.TaintedObject("BSPrim.setFriction", delegate()
+                PhysScene.TaintedObject(LocalID, "BSPrim.setFriction", delegate()
                 {
                     UpdatePhysicalParameters();
                 });
@@ -707,7 +656,7 @@ public class BSPrim : BSPhysObject
             if (base.Restitution != value)
             {
                 base.Restitution = value;
-                PhysicsScene.TaintedObject("BSPrim.setRestitution", delegate()
+                PhysScene.TaintedObject(LocalID, "BSPrim.setRestitution", delegate()
                 {
                     UpdatePhysicalParameters();
                 });
@@ -724,7 +673,7 @@ public class BSPrim : BSPhysObject
             if (base.Density != value)
             {
                 base.Density = value;
-                PhysicsScene.TaintedObject("BSPrim.setDensity", delegate()
+                PhysScene.TaintedObject(LocalID, "BSPrim.setDensity", delegate()
                 {
                     UpdatePhysicalParameters();
                 });
@@ -739,93 +688,66 @@ public class BSPrim : BSPhysObject
             if (base.GravModifier != value)
             {
                 base.GravModifier = value;
-                PhysicsScene.TaintedObject("BSPrim.setGravityModifier", delegate()
+                PhysScene.TaintedObject(LocalID, "BSPrim.setGravityModifier", delegate()
                 {
                     UpdatePhysicalParameters();
                 });
             }
         }
     }
-    public override OMV.Vector3 RawVelocity
-    {
-        get { return _velocity; }
-        set { _velocity = value; }
-    }
     public override OMV.Vector3 Velocity {
-        get { return _velocity; }
+        get { return RawVelocity; }
         set {
-            _velocity = value;
-            PhysicsScene.TaintedObject("BSPrim.setVelocity", delegate()
+            RawVelocity = value;
+            PhysScene.TaintedObject(LocalID, "BSPrim.setVelocity", delegate()
             {
-                // DetailLog("{0},BSPrim.SetVelocity,taint,vel={1}", LocalID, _velocity);
-                ForceVelocity = _velocity;
+                // DetailLog("{0},BSPrim.SetVelocity,taint,vel={1}", LocalID, RawVelocity);
+                ForceVelocity = RawVelocity;
             });
         }
     }
     public override OMV.Vector3 ForceVelocity {
-        get { return _velocity; }
+        get { return RawVelocity; }
         set {
-            PhysicsScene.AssertInTaintTime("BSPrim.ForceVelocity");
+            PhysScene.AssertInTaintTime("BSPrim.ForceVelocity");
 
-            _velocity = Util.ClampV(value, BSParam.MaxLinearVelocity);
+            RawVelocity = Util.ClampV(value, BSParam.MaxLinearVelocity);
             if (PhysBody.HasPhysicalBody)
             {
-                DetailLog("{0},BSPrim.ForceVelocity,taint,vel={1}", LocalID, _velocity);
-                PhysicsScene.PE.SetLinearVelocity(PhysBody, _velocity);
+                DetailLog("{0},BSPrim.ForceVelocity,taint,vel={1}", LocalID, RawVelocity);
+                PhysScene.PE.SetLinearVelocity(PhysBody, RawVelocity);
                 ActivateIfPhysical(false);
             }
         }
     }
     public override OMV.Vector3 Torque {
-        get { return _torque; }
+        get { return RawTorque; }
         set {
-            _torque = value;
-            if (_torque != OMV.Vector3.Zero)
+            RawTorque = value;
+            EnableActor(RawTorque != OMV.Vector3.Zero, SetTorqueActorName, delegate()
             {
-                // If the torque is non-zero, it must be reapplied each tick because
-                //    Bullet clears the forces applied last frame.
-                RegisterPreStepAction("BSPrim.setTorque", LocalID,
-                    delegate(float timeStep)
-                    {
-                        if (!IsPhysicallyActive || _torque == OMV.Vector3.Zero)
-                        {
-                            UnRegisterPreStepAction("BSPrim.setTorque", LocalID);
-                            return;
-                        }
-
-                        if (PhysBody.HasPhysicalBody)
-                            AddAngularForce(_torque, false, true);
-                    }
-                );
-            }
-            else
-            {
-                UnRegisterPreStepAction("BSPrim.setTorque", LocalID);
-            }
-            // DetailLog("{0},BSPrim.SetTorque,call,torque={1}", LocalID, _torque);
+                return new BSActorSetTorque(PhysScene, this, SetTorqueActorName);
+            });
+            DetailLog("{0},BSPrim.SetTorque,call,torque={1}", LocalID, RawTorque);
         }
     }
     public override OMV.Vector3 Acceleration {
         get { return _acceleration; }
         set { _acceleration = value; }
     }
-    public override OMV.Quaternion RawOrientation
-    {
-        get { return _orientation; }
-        set { _orientation = value; }
-    }
+
     public override OMV.Quaternion Orientation {
         get {
-            return _orientation;
+            return RawOrientation;
         }
         set {
-            if (_orientation == value)
+            if (RawOrientation == value)
                 return;
-            _orientation = value;
+            RawOrientation = value;
 
-            PhysicsScene.TaintedObject("BSPrim.setOrientation", delegate()
+            PhysScene.TaintedObject(LocalID, "BSPrim.setOrientation", delegate()
             {
-                ForceOrientation = _orientation;
+                ForceOrientation = RawOrientation;
             });
         }
     }
@@ -834,14 +756,14 @@ public class BSPrim : BSPhysObject
     {
         get
         {
-            _orientation = PhysicsScene.PE.GetOrientation(PhysBody);
-            return _orientation;
+            RawOrientation = PhysScene.PE.GetOrientation(PhysBody);
+            return RawOrientation;
         }
         set
         {
-            _orientation = value;
+            RawOrientation = value;
             if (PhysBody.HasPhysicalBody)
-                PhysicsScene.PE.SetTranslation(PhysBody, _position, _orientation);
+                PhysScene.PE.SetTranslation(PhysBody, RawPosition, RawOrientation);
         }
     }
     public override int PhysicsActorType {
@@ -854,7 +776,7 @@ public class BSPrim : BSPhysObject
             if (_isPhysical != value)
             {
                 _isPhysical = value;
-                PhysicsScene.TaintedObject("BSPrim.setIsPhysical", delegate()
+                PhysScene.TaintedObject(LocalID, "BSPrim.setIsPhysical", delegate()
                 {
                     DetailLog("{0},setIsPhysical,taint,isPhys={1}", LocalID, _isPhysical);
                     SetObjectDynamic(true);
@@ -898,24 +820,25 @@ public class BSPrim : BSPhysObject
     //     isSolid: other objects bounce off of this object
     //     isVolumeDetect: other objects pass through but can generate collisions
     //     collisionEvents: whether this object returns collision events
+    // NOTE: overloaded by BSPrimLinkable to also update linkset physical parameters.
     public virtual void UpdatePhysicalParameters()
     {
         if (!PhysBody.HasPhysicalBody)
         {
             // This would only happen if updates are called for during initialization when the body is not set up yet.
-            DetailLog("{0},BSPrim.UpdatePhysicalParameters,taint,calledWithNoPhysBody", LocalID);
+            // DetailLog("{0},BSPrim.UpdatePhysicalParameters,taint,calledWithNoPhysBody", LocalID);
             return;
         }
 
         // Mangling all the physical properties requires the object not be in the physical world.
         // This is a NOOP if the object is not in the world (BulletSim and Bullet ignore objects not found).
-        PhysicsScene.PE.RemoveObjectFromWorld(PhysicsScene.World, PhysBody);
+        PhysScene.PE.RemoveObjectFromWorld(PhysScene.World, PhysBody);
 
         // Set up the object physicalness (does gravity and collisions move this object)
         MakeDynamic(IsStatic);
 
         // Update vehicle specific parameters (after MakeDynamic() so can change physical parameters)
-        VehicleController.Refresh();
+        PhysicalActors.Refresh();
 
         // Arrange for collision events if the simulator wants them
         EnableCollisions(SubscribedEvents());
@@ -926,10 +849,11 @@ public class BSPrim : BSPhysObject
         AddObjectToPhysicalWorld();
 
         // Rebuild its shape
-        PhysicsScene.PE.UpdateSingleAabb(PhysicsScene.World, PhysBody);
+        PhysScene.PE.UpdateSingleAabb(PhysScene.World, PhysBody);
 
         DetailLog("{0},BSPrim.UpdatePhysicalParameters,taintExit,static={1},solid={2},mass={3},collide={4},cf={5:X},cType={6},body={7},shape={8}",
-                        LocalID, IsStatic, IsSolid, Mass, SubscribedEvents(), CurrentCollisionFlags, PhysBody.collisionType, PhysBody, PhysShape);
+                                    LocalID, IsStatic, IsSolid, Mass, SubscribedEvents(),
+                                    CurrentCollisionFlags, PhysBody.collisionType, PhysBody, PhysShape);
     }
 
     // "Making dynamic" means changing to and from static.
@@ -942,28 +866,28 @@ public class BSPrim : BSPhysObject
         if (makeStatic)
         {
             // Become a Bullet 'static' object type
-            CurrentCollisionFlags = PhysicsScene.PE.AddToCollisionFlags(PhysBody, CollisionFlags.CF_STATIC_OBJECT);
+            CurrentCollisionFlags = PhysScene.PE.AddToCollisionFlags(PhysBody, CollisionFlags.CF_STATIC_OBJECT);
             // Stop all movement
             ZeroMotion(true);
 
             // Set various physical properties so other object interact properly
-            PhysicsScene.PE.SetFriction(PhysBody, Friction);
-            PhysicsScene.PE.SetRestitution(PhysBody, Restitution);
-            PhysicsScene.PE.SetContactProcessingThreshold(PhysBody, BSParam.ContactProcessingThreshold);
+            PhysScene.PE.SetFriction(PhysBody, Friction);
+            PhysScene.PE.SetRestitution(PhysBody, Restitution);
+            PhysScene.PE.SetContactProcessingThreshold(PhysBody, BSParam.ContactProcessingThreshold);
 
             // Mass is zero which disables a bunch of physics stuff in Bullet
             UpdatePhysicalMassProperties(0f, false);
             // Set collision detection parameters
             if (BSParam.CcdMotionThreshold > 0f)
             {
-                PhysicsScene.PE.SetCcdMotionThreshold(PhysBody, BSParam.CcdMotionThreshold);
-                PhysicsScene.PE.SetCcdSweptSphereRadius(PhysBody, BSParam.CcdSweptSphereRadius);
+                PhysScene.PE.SetCcdMotionThreshold(PhysBody, BSParam.CcdMotionThreshold);
+                PhysScene.PE.SetCcdSweptSphereRadius(PhysBody, BSParam.CcdSweptSphereRadius);
             }
 
             // The activation state is 'disabled' so Bullet will not try to act on it.
             // PhysicsScene.PE.ForceActivationState(PhysBody, ActivationState.DISABLE_SIMULATION);
             // Start it out sleeping and physical actions could wake it up.
-            PhysicsScene.PE.ForceActivationState(PhysBody, ActivationState.ISLAND_SLEEPING);
+            PhysScene.PE.ForceActivationState(PhysBody, ActivationState.ISLAND_SLEEPING);
 
             // This collides like a static object
             PhysBody.collisionType = CollisionType.Static;
@@ -971,11 +895,11 @@ public class BSPrim : BSPhysObject
         else
         {
             // Not a Bullet static object
-            CurrentCollisionFlags = PhysicsScene.PE.RemoveFromCollisionFlags(PhysBody, CollisionFlags.CF_STATIC_OBJECT);
+            CurrentCollisionFlags = PhysScene.PE.RemoveFromCollisionFlags(PhysBody, CollisionFlags.CF_STATIC_OBJECT);
 
             // Set various physical properties so other object interact properly
-            PhysicsScene.PE.SetFriction(PhysBody, Friction);
-            PhysicsScene.PE.SetRestitution(PhysBody, Restitution);
+            PhysScene.PE.SetFriction(PhysBody, Friction);
+            PhysScene.PE.SetRestitution(PhysBody, Restitution);
             // DetailLog("{0},BSPrim.MakeDynamic,frict={1},rest={2}", LocalID, Friction, Restitution);
 
             // per http://www.bulletphysics.org/Bullet/phpBB3/viewtopic.php?t=3382
@@ -983,8 +907,8 @@ public class BSPrim : BSPhysObject
             // PhysicsScene.PE.ClearAllForces(BSBody);
 
             // For good measure, make sure the transform is set through to the motion state
-            ForcePosition = _position;
-            ForceVelocity = _velocity;
+            ForcePosition = RawPosition;
+            ForceVelocity = RawVelocity;
             ForceRotationalVelocity = _rotationalVelocity;
 
             // A dynamic object has mass
@@ -993,22 +917,22 @@ public class BSPrim : BSPhysObject
             // Set collision detection parameters
             if (BSParam.CcdMotionThreshold > 0f)
             {
-                PhysicsScene.PE.SetCcdMotionThreshold(PhysBody, BSParam.CcdMotionThreshold);
-                PhysicsScene.PE.SetCcdSweptSphereRadius(PhysBody, BSParam.CcdSweptSphereRadius);
+                PhysScene.PE.SetCcdMotionThreshold(PhysBody, BSParam.CcdMotionThreshold);
+                PhysScene.PE.SetCcdSweptSphereRadius(PhysBody, BSParam.CcdSweptSphereRadius);
             }
 
             // Various values for simulation limits
-            PhysicsScene.PE.SetDamping(PhysBody, BSParam.LinearDamping, BSParam.AngularDamping);
-            PhysicsScene.PE.SetDeactivationTime(PhysBody, BSParam.DeactivationTime);
-            PhysicsScene.PE.SetSleepingThresholds(PhysBody, BSParam.LinearSleepingThreshold, BSParam.AngularSleepingThreshold);
-            PhysicsScene.PE.SetContactProcessingThreshold(PhysBody, BSParam.ContactProcessingThreshold);
+            PhysScene.PE.SetDamping(PhysBody, BSParam.LinearDamping, BSParam.AngularDamping);
+            PhysScene.PE.SetDeactivationTime(PhysBody, BSParam.DeactivationTime);
+            PhysScene.PE.SetSleepingThresholds(PhysBody, BSParam.LinearSleepingThreshold, BSParam.AngularSleepingThreshold);
+            PhysScene.PE.SetContactProcessingThreshold(PhysBody, BSParam.ContactProcessingThreshold);
 
             // This collides like an object.
             PhysBody.collisionType = CollisionType.Dynamic;
 
             // Force activation of the object so Bullet will act on it.
             // Must do the ForceActivationState2() to overcome the DISABLE_SIMULATION from static objects.
-            PhysicsScene.PE.ForceActivationState(PhysBody, ActivationState.ACTIVE_TAG);
+            PhysScene.PE.ForceActivationState(PhysBody, ActivationState.ACTIVE_TAG);
         }
     }
 
@@ -1018,7 +942,7 @@ public class BSPrim : BSPhysObject
     //     the functions after this one set up the state of a possibly newly created collision body.
     private void MakeSolid(bool makeSolid)
     {
-        CollisionObjectTypes bodyType = (CollisionObjectTypes)PhysicsScene.PE.GetBodyType(PhysBody);
+        CollisionObjectTypes bodyType = (CollisionObjectTypes)PhysScene.PE.GetBodyType(PhysBody);
         if (makeSolid)
         {
             // Verify the previous code created the correct shape for this type of thing.
@@ -1026,7 +950,7 @@ public class BSPrim : BSPhysObject
             {
                 m_log.ErrorFormat("{0} MakeSolid: physical body of wrong type for solidity. id={1}, type={2}", LogHeader, LocalID, bodyType);
             }
-            CurrentCollisionFlags = PhysicsScene.PE.RemoveFromCollisionFlags(PhysBody, CollisionFlags.CF_NO_CONTACT_RESPONSE);
+            CurrentCollisionFlags = PhysScene.PE.RemoveFromCollisionFlags(PhysBody, CollisionFlags.CF_NO_CONTACT_RESPONSE);
         }
         else
         {
@@ -1034,32 +958,23 @@ public class BSPrim : BSPhysObject
             {
                 m_log.ErrorFormat("{0} MakeSolid: physical body of wrong type for non-solidness. id={1}, type={2}", LogHeader, LocalID, bodyType);
             }
-            CurrentCollisionFlags = PhysicsScene.PE.AddToCollisionFlags(PhysBody, CollisionFlags.CF_NO_CONTACT_RESPONSE);
+            CurrentCollisionFlags = PhysScene.PE.AddToCollisionFlags(PhysBody, CollisionFlags.CF_NO_CONTACT_RESPONSE);
 
             // Change collision info from a static object to a ghosty collision object
             PhysBody.collisionType = CollisionType.VolumeDetect;
         }
     }
 
-    // Enable physical actions. Bullet will keep sleeping non-moving physical objects so
-    //     they need waking up when parameters are changed.
-    // Called in taint-time!!
-    private void ActivateIfPhysical(bool forceIt)
-    {
-        if (IsPhysical && PhysBody.HasPhysicalBody)
-            PhysicsScene.PE.Activate(PhysBody, forceIt);
-    }
-
     // Turn on or off the flag controlling whether collision events are returned to the simulator.
     private void EnableCollisions(bool wantsCollisionEvents)
     {
         if (wantsCollisionEvents)
         {
-            CurrentCollisionFlags = PhysicsScene.PE.AddToCollisionFlags(PhysBody, CollisionFlags.BS_SUBSCRIBE_COLLISION_EVENTS);
+            CurrentCollisionFlags = PhysScene.PE.AddToCollisionFlags(PhysBody, CollisionFlags.BS_SUBSCRIBE_COLLISION_EVENTS);
         }
         else
         {
-            CurrentCollisionFlags = PhysicsScene.PE.RemoveFromCollisionFlags(PhysBody, CollisionFlags.BS_SUBSCRIBE_COLLISION_EVENTS);
+            CurrentCollisionFlags = PhysScene.PE.RemoveFromCollisionFlags(PhysBody, CollisionFlags.BS_SUBSCRIBE_COLLISION_EVENTS);
         }
     }
 
@@ -1070,7 +985,7 @@ public class BSPrim : BSPhysObject
     {
         if (PhysBody.HasPhysicalBody)
         {
-            PhysicsScene.PE.AddObjectToWorld(PhysicsScene.World, PhysBody);
+            PhysScene.PE.AddObjectToWorld(PhysScene.World, PhysBody);
         }
         else
         {
@@ -1105,12 +1020,12 @@ public class BSPrim : BSPhysObject
     public override bool FloatOnWater {
         set {
             _floatOnWater = value;
-            PhysicsScene.TaintedObject("BSPrim.setFloatOnWater", delegate()
+            PhysScene.TaintedObject(LocalID, "BSPrim.setFloatOnWater", delegate()
             {
                 if (_floatOnWater)
-                    CurrentCollisionFlags = PhysicsScene.PE.AddToCollisionFlags(PhysBody, CollisionFlags.BS_FLOATS_ON_WATER);
+                    CurrentCollisionFlags = PhysScene.PE.AddToCollisionFlags(PhysBody, CollisionFlags.BS_FLOATS_ON_WATER);
                 else
-                    CurrentCollisionFlags = PhysicsScene.PE.RemoveFromCollisionFlags(PhysBody, CollisionFlags.BS_FLOATS_ON_WATER);
+                    CurrentCollisionFlags = PhysScene.PE.RemoveFromCollisionFlags(PhysBody, CollisionFlags.BS_FLOATS_ON_WATER);
             });
         }
     }
@@ -1122,7 +1037,7 @@ public class BSPrim : BSPhysObject
             _rotationalVelocity = value;
             Util.ClampV(_rotationalVelocity, BSParam.MaxAngularVelocity);
             // m_log.DebugFormat("{0}: RotationalVelocity={1}", LogHeader, _rotationalVelocity);
-            PhysicsScene.TaintedObject("BSPrim.setRotationalVelocity", delegate()
+            PhysScene.TaintedObject(LocalID, "BSPrim.setRotationalVelocity", delegate()
             {
                 ForceRotationalVelocity = _rotationalVelocity;
             });
@@ -1137,7 +1052,7 @@ public class BSPrim : BSPhysObject
             if (PhysBody.HasPhysicalBody)
             {
                 DetailLog("{0},BSPrim.ForceRotationalVel,taint,rotvel={1}", LocalID, _rotationalVelocity);
-                PhysicsScene.PE.SetAngularVelocity(PhysBody, _rotationalVelocity);
+                PhysScene.PE.SetAngularVelocity(PhysBody, _rotationalVelocity);
                 // PhysicsScene.PE.SetInterpolationAngularVelocity(PhysBody, _rotationalVelocity);
                 ActivateIfPhysical(false);
             }
@@ -1153,7 +1068,7 @@ public class BSPrim : BSPhysObject
         get { return _buoyancy; }
         set {
             _buoyancy = value;
-            PhysicsScene.TaintedObject("BSPrim.setBuoyancy", delegate()
+            PhysScene.TaintedObject(LocalID, "BSPrim.setBuoyancy", delegate()
             {
                 ForceBuoyancy = _buoyancy;
             });
@@ -1171,179 +1086,54 @@ public class BSPrim : BSPhysObject
         }
     }
 
-    // Used for MoveTo
-    public override OMV.Vector3 PIDTarget {
-        set
-        {
-            // TODO: add a sanity check -- don't move more than a region or something like that.
-            _PIDTarget = value;
-        }
-    }
-    public override float PIDTau {
-        set { _PIDTau = value; }
-    }
     public override bool PIDActive {
         set {
-            if (value)
+            base.MoveToTargetActive = value;
+            EnableActor(MoveToTargetActive, MoveToTargetActorName, delegate()
             {
-                // We're taking over after this.
-                ZeroMotion(true);
-
-                _targetMotor = new BSVMotor("BSPrim.PIDTarget",
-                                            _PIDTau,                    // timeScale
-                                            BSMotor.Infinite,           // decay time scale
-                                            BSMotor.InfiniteVector,     // friction timescale
-                                            1f                          // efficiency
-                );
-                _targetMotor.PhysicsScene = PhysicsScene; // DEBUG DEBUG so motor will output detail log messages.
-                _targetMotor.SetTarget(_PIDTarget);
-                _targetMotor.SetCurrent(RawPosition);
-                /*
-                _targetMotor = new BSPIDVMotor("BSPrim.PIDTarget");
-                _targetMotor.PhysicsScene = PhysicsScene; // DEBUG DEBUG so motor will output detail log messages.
-
-                _targetMotor.SetTarget(_PIDTarget);
-                _targetMotor.SetCurrent(RawPosition);
-                _targetMotor.TimeScale = _PIDTau;
-                _targetMotor.Efficiency = 1f;
-                 */
-
-                RegisterPreStepAction("BSPrim.PIDTarget", LocalID, delegate(float timeStep)
-                {
-                    if (!IsPhysicallyActive)
-                    {
-                        UnRegisterPreStepAction("BSPrim.PIDTarget", LocalID);
-                        return;
-                    }
-
-                    OMV.Vector3 origPosition = RawPosition;     // DEBUG DEBUG (for printout below)
-
-                    // 'movePosition' is where we'd like the prim to be at this moment.
-                    OMV.Vector3 movePosition = RawPosition + _targetMotor.Step(timeStep);
+                return new BSActorMoveToTarget(PhysScene, this, MoveToTargetActorName);
+            });
+        }
+    }
 
-                    // If we are very close to our target, turn off the movement motor.
-                    if (_targetMotor.ErrorIsZero())
-                    {
-                        DetailLog("{0},BSPrim.PIDTarget,zeroMovement,movePos={1},pos={2},mass={3}",
-                                                LocalID, movePosition, RawPosition, Mass);
-                        ForcePosition = _targetMotor.TargetValue;
-                        _targetMotor.Enabled = false;
-                    }
-                    else
-                    {
-                        _position = movePosition;
-                        PositionSanityCheck(true /* intaintTime */);
-                        ForcePosition = _position;
-                    }
-                    DetailLog("{0},BSPrim.PIDTarget,move,fromPos={1},movePos={2}", LocalID, origPosition, movePosition);
-                });
-            }
-            else
+    public override OMV.Vector3 PIDTarget
+    {
+        set
+        {
+            base.PIDTarget = value;
+            BSActor actor;
+            if (PhysicalActors.TryGetActor(MoveToTargetActorName, out actor))
             {
-                // Stop any targetting
-                UnRegisterPreStepAction("BSPrim.PIDTarget", LocalID);
+                // if the actor exists, tell it to refresh its values.
+                actor.Refresh();
             }
+            
         }
     }
-
     // Used for llSetHoverHeight and maybe vehicle height
     // Hover Height will override MoveTo target's Z
     public override bool PIDHoverActive {
         set {
-            if (value)
+            base.HoverActive = value;
+            EnableActor(HoverActive, HoverActorName, delegate()
             {
-                // Turning the target on
-                _hoverMotor = new BSFMotor("BSPrim.Hover",
-                                            _PIDHoverTau,               // timeScale
-                                            BSMotor.Infinite,           // decay time scale
-                                            BSMotor.Infinite,           // friction timescale
-                                            1f                          // efficiency
-                );
-                _hoverMotor.SetTarget(ComputeCurrentPIDHoverHeight());
-                _hoverMotor.SetCurrent(RawPosition.Z);
-                _hoverMotor.PhysicsScene = PhysicsScene; // DEBUG DEBUG so motor will output detail log messages.
-
-                RegisterPreStepAction("BSPrim.Hover", LocalID, delegate(float timeStep)
-                {
-                    // Don't do hovering while the object is selected.
-                    if (!IsPhysicallyActive)
-                        return;
-
-                    _hoverMotor.SetCurrent(RawPosition.Z);
-                    _hoverMotor.SetTarget(ComputeCurrentPIDHoverHeight());
-                    float targetHeight = _hoverMotor.Step(timeStep);
-
-                    // 'targetHeight' is where we'd like the Z of the prim to be at this moment.
-                    // Compute the amount of force to push us there.
-                    float moveForce = (targetHeight - RawPosition.Z) * Mass;
-                    // Undo anything the object thinks it's doing at the moment
-                    moveForce = -RawVelocity.Z * Mass;
-
-                    PhysicsScene.PE.ApplyCentralImpulse(PhysBody, new OMV.Vector3(0f, 0f, moveForce));
-                    DetailLog("{0},BSPrim.Hover,move,targHt={1},moveForce={2},mass={3}", LocalID, targetHeight, moveForce, Mass);
-                });
-            }
-            else
-            {
-                UnRegisterPreStepAction("BSPrim.Hover", LocalID);
-            }
-        }
-    }
-    public override float PIDHoverHeight {
-        set { _PIDHoverHeight = value; }
-    }
-    public override PIDHoverType PIDHoverType {
-        set { _PIDHoverType = value; }
-    }
-    public override float PIDHoverTau {
-        set { _PIDHoverTau = value; }
-    }
-    // Based on current position, determine what we should be hovering at now.
-    // Must recompute often. What if we walked offa cliff>
-    private float ComputeCurrentPIDHoverHeight()
-    {
-        float ret = _PIDHoverHeight;
-        float groundHeight = PhysicsScene.TerrainManager.GetTerrainHeightAtXYZ(RawPosition);
-
-        switch (_PIDHoverType)
-        {
-            case PIDHoverType.Ground:
-                ret = groundHeight + _PIDHoverHeight;
-                break;
-            case PIDHoverType.GroundAndWater:
-                float waterHeight = PhysicsScene.TerrainManager.GetWaterLevelAtXYZ(RawPosition);
-                if (groundHeight > waterHeight)
-                {
-                    ret = groundHeight + _PIDHoverHeight;
-                }
-                else
-                {
-                    ret = waterHeight + _PIDHoverHeight;
-                }
-                break;
+                return new BSActorHover(PhysScene, this, HoverActorName);
+            });
         }
-        return ret;
     }
 
-
-    // For RotLookAt
-    public override OMV.Quaternion APIDTarget { set { return; } }
-    public override bool APIDActive { set { return; } }
-    public override float APIDStrength { set { return; } }
-    public override float APIDDamping { set { return; } }
-
     public override void AddForce(OMV.Vector3 force, bool pushforce) {
         // Per documentation, max force is limited.
         OMV.Vector3 addForce = Util.ClampV(force, BSParam.MaxAddForceMagnitude);
 
         // Since this force is being applied in only one step, make this a force per second.
-        addForce /= PhysicsScene.LastTimeStep;
+        addForce /= PhysScene.LastTimeStep;
         AddForce(addForce, pushforce, false /* inTaintTime */);
     }
 
     // Applying a force just adds this to the total force on the object.
     // This added force will only last the next simulation tick.
-    public void AddForce(OMV.Vector3 force, bool pushforce, bool inTaintTime) {
+    public override void AddForce(OMV.Vector3 force, bool pushforce, bool inTaintTime) {
         // for an object, doesn't matter if force is a pushforce or not
         if (IsPhysicallyActive)
         {
@@ -1352,13 +1142,15 @@ public class BSPrim : BSPhysObject
                 // DetailLog("{0},BSPrim.addForce,call,force={1}", LocalID, addForce);
 
                 OMV.Vector3 addForce = force;
-                PhysicsScene.TaintedObject(inTaintTime, "BSPrim.AddForce", delegate()
+                PhysScene.TaintedObject(inTaintTime, LocalID, "BSPrim.AddForce", delegate()
                 {
-                    // Bullet adds this central force to the total force for this tick
+                    // Bullet adds this central force to the total force for this tick.
+                    // Deep down in Bullet:
+                    //      linearVelocity += totalForce / mass * timeStep;
                     DetailLog("{0},BSPrim.addForce,taint,force={1}", LocalID, addForce);
                     if (PhysBody.HasPhysicalBody)
                     {
-                        PhysicsScene.PE.ApplyCentralForce(PhysBody, addForce);
+                        PhysScene.PE.ApplyCentralForce(PhysBody, addForce);
                         ActivateIfPhysical(false);
                     }
                 });
@@ -1380,13 +1172,13 @@ public class BSPrim : BSPhysObject
                 OMV.Vector3 addImpulse = Util.ClampV(impulse, BSParam.MaxAddForceMagnitude);
                 // DetailLog("{0},BSPrim.addForceImpulse,call,impulse={1}", LocalID, impulse);
 
-                PhysicsScene.TaintedObject(inTaintTime, "BSPrim.AddImpulse", delegate()
+                PhysScene.TaintedObject(inTaintTime, LocalID, "BSPrim.AddImpulse", delegate()
                 {
                     // Bullet adds this impulse immediately to the velocity
                     DetailLog("{0},BSPrim.addForceImpulse,taint,impulseforce={1}", LocalID, addImpulse);
                     if (PhysBody.HasPhysicalBody)
                     {
-                        PhysicsScene.PE.ApplyCentralImpulse(PhysBody, addImpulse);
+                        PhysScene.PE.ApplyCentralImpulse(PhysBody, addImpulse);
                         ActivateIfPhysical(false);
                     }
                 });
@@ -1399,20 +1191,18 @@ public class BSPrim : BSPhysObject
         }
     }
 
-    public override void AddAngularForce(OMV.Vector3 force, bool pushforce) {
-        AddAngularForce(force, pushforce, false);
-    }
-    public void AddAngularForce(OMV.Vector3 force, bool pushforce, bool inTaintTime)
+    // BSPhysObject.AddAngularForce()
+    public override void AddAngularForce(OMV.Vector3 force, bool pushforce, bool inTaintTime)
     {
         if (force.IsFinite())
         {
             OMV.Vector3 angForce = force;
-            PhysicsScene.TaintedObject(inTaintTime, "BSPrim.AddAngularForce", delegate()
+            PhysScene.TaintedObject(inTaintTime, LocalID, "BSPrim.AddAngularForce", delegate()
             {
                 if (PhysBody.HasPhysicalBody)
                 {
                     DetailLog("{0},BSPrim.AddAngularForce,taint,angForce={1}", LocalID, angForce);
-                    PhysicsScene.PE.ApplyTorque(PhysBody, angForce);
+                    PhysScene.PE.ApplyTorque(PhysBody, angForce);
                     ActivateIfPhysical(false);
                 }
             });
@@ -1431,11 +1221,11 @@ public class BSPrim : BSPhysObject
     public void ApplyTorqueImpulse(OMV.Vector3 impulse, bool inTaintTime)
     {
         OMV.Vector3 applyImpulse = impulse;
-        PhysicsScene.TaintedObject(inTaintTime, "BSPrim.ApplyTorqueImpulse", delegate()
+        PhysScene.TaintedObject(inTaintTime, LocalID, "BSPrim.ApplyTorqueImpulse", delegate()
         {
             if (PhysBody.HasPhysicalBody)
             {
-                PhysicsScene.PE.ApplyTorqueImpulse(PhysBody, applyImpulse);
+                PhysScene.PE.ApplyTorqueImpulse(PhysBody, applyImpulse);
                 ActivateIfPhysical(false);
             }
         });
@@ -1721,9 +1511,11 @@ public class BSPrim : BSPhysObject
         volume *= (profileEnd - profileBegin);
 
         returnMass = Density * BSParam.DensityScaleFactor * volume;
-        DetailLog("{0},BSPrim.CalculateMass,den={1},vol={2},mass={3}", LocalID, Density, volume, returnMass);
 
         returnMass = Util.Clamp(returnMass, BSParam.MinimumObjectMass, BSParam.MaximumObjectMass);
+        // DetailLog("{0},BSPrim.CalculateMass,den={1},vol={2},mass={3}", LocalID, Density, volume, returnMass);
+        DetailLog("{0},BSPrim.CalculateMass,den={1},vol={2},mass={3},pathB={4},pathE={5},profB={6},profE={7},siz={8}",
+                            LocalID, Density, volume, returnMass, pathBegin, pathEnd, profileBegin, profileEnd, _size);
 
         return returnMass;
     }// end CalculateMass
@@ -1736,13 +1528,14 @@ public class BSPrim : BSPhysObject
     {
         // Create the correct physical representation for this type of object.
         // Updates base.PhysBody and base.PhysShape with the new information.
-        // Ignore 'forceRebuild'. This routine makes the right choices and changes of necessary.
-        PhysicsScene.Shapes.GetBodyAndShape(false /*forceRebuild */, PhysicsScene.World, this, null, delegate(BulletBody dBody)
+        // Ignore 'forceRebuild'. 'GetBodyAndShape' makes the right choices and changes of necessary.
+        PhysScene.Shapes.GetBodyAndShape(false /*forceRebuild */, PhysScene.World, this, delegate(BulletBody pBody, BulletShape pShape)
         {
             // Called if the current prim body is about to be destroyed.
             // Remove all the physical dependencies on the old body.
             // (Maybe someday make the changing of BSShape an event to be subscribed to by BSLinkset, ...)
-            RemoveBodyDependencies();
+            // Note: this virtual function is overloaded by BSPrimLinkable to remove linkset constraints.
+            RemoveDependencies();
         });
 
         // Make sure the properties are set on the new object
@@ -1750,33 +1543,45 @@ public class BSPrim : BSPhysObject
         return;
     }
 
-    protected virtual void RemoveBodyDependencies()
+    // Called at taint-time
+    protected virtual void RemoveDependencies()
     {
-        VehicleController.RemoveBodyDependencies(this);
+        PhysicalActors.RemoveDependencies();
+    }
+
+    #region Extension
+    public override object Extension(string pFunct, params object[] pParams)
+    {
+        DetailLog("{0} BSPrim.Extension,op={1}", LocalID, pFunct);
+        object ret = null;
+        switch (pFunct)
+        {
+            default:
+                ret = base.Extension(pFunct, pParams);
+                break;
+        }
+        return ret;
     }
+    #endregion  // Extension
 
     // The physics engine says that properties have updated. Update same and inform
     // the world that things have changed.
+    // NOTE: BSPrim.UpdateProperties is overloaded by BSPrimLinkable which modifies updates from root and children prims.
+    // NOTE: BSPrim.UpdateProperties is overloaded by BSPrimDisplaced which handles mapping physical position to simulator position.
     public override void UpdateProperties(EntityProperties entprop)
     {
+        // Let anyone (like the actors) modify the updated properties before they are pushed into the object and the simulator.
         TriggerPreUpdatePropertyAction(ref entprop);
 
-        // A temporary kludge to suppress the rotational effects introduced on vehicles by Bullet
-        // TODO: handle physics introduced by Bullet with computed vehicle physics.
-        if (VehicleController.IsActive)
-        {
-            entprop.RotationalVelocity = OMV.Vector3.Zero;
-        }
-
         // DetailLog("{0},BSPrim.UpdateProperties,entry,entprop={1}", LocalID, entprop);   // DEBUG DEBUG
 
         // Assign directly to the local variables so the normal set actions do not happen
-        _position = entprop.Position;
-        _orientation = entprop.Rotation;
+        RawPosition = entprop.Position;
+        RawOrientation = entprop.Rotation;
         // DEBUG DEBUG DEBUG -- smooth velocity changes a bit. The simulator seems to be
         //    very sensitive to velocity changes.
-        if (entprop.Velocity == OMV.Vector3.Zero || !entprop.Velocity.ApproxEquals(_velocity, BSParam.UpdateVelocityChangeThreshold))
-            _velocity = entprop.Velocity;
+        if (entprop.Velocity == OMV.Vector3.Zero || !entprop.Velocity.ApproxEquals(RawVelocity, BSParam.UpdateVelocityChangeThreshold))
+            RawVelocity = entprop.Velocity;
         _acceleration = entprop.Acceleration;
         _rotationalVelocity = entprop.RotationalVelocity;
 
@@ -1785,29 +1590,20 @@ public class BSPrim : BSPhysObject
         // The sanity check can change the velocity and/or position.
         if (PositionSanityCheck(true /* inTaintTime */ ))
         {
-            entprop.Position = _position;
-            entprop.Velocity = _velocity;
+            entprop.Position = RawPosition;
+            entprop.Velocity = RawVelocity;
             entprop.RotationalVelocity = _rotationalVelocity;
             entprop.Acceleration = _acceleration;
         }
 
-        OMV.Vector3 direction = OMV.Vector3.UnitX * _orientation;   // DEBUG DEBUG DEBUG
+        OMV.Vector3 direction = OMV.Vector3.UnitX * RawOrientation;   // DEBUG DEBUG DEBUG
         DetailLog("{0},BSPrim.UpdateProperties,call,entProp={1},dir={2}", LocalID, entprop, direction);
 
         // remember the current and last set values
         LastEntityProperties = CurrentEntityProperties;
         CurrentEntityProperties = entprop;
 
-        base.RequestPhysicsterseUpdate();
-            /*
-        else
-        {
-            // For debugging, report the movement of children
-            DetailLog("{0},BSPrim.UpdateProperties,child,pos={1},orient={2},vel={3},accel={4},rotVel={5}",
-                    LocalID, entprop.Position, entprop.Rotation, entprop.Velocity,
-                    entprop.Acceleration, entprop.RotationalVelocity);
-        }
-             */
+        PhysScene.PostUpdate(this);
     }
 }
 }
diff --git a/OpenSim/Region/Physics/BulletSPlugin/BSPrimDisplaced.cs b/OpenSim/Region/Physics/BulletSPlugin/BSPrimDisplaced.cs
index f1c3b5c..2eb1440 100755
--- a/OpenSim/Region/Physics/BulletSPlugin/BSPrimDisplaced.cs
+++ b/OpenSim/Region/Physics/BulletSPlugin/BSPrimDisplaced.cs
@@ -23,11 +23,6 @@
  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- * The quotations from http://wiki.secondlife.com/wiki/Linden_Vehicle_Tutorial
- * are Copyright (c) 2009 Linden Research, Inc and are used under their license
- * of Creative Commons Attribution-Share Alike 3.0
- * (http://creativecommons.org/licenses/by-sa/3.0/).
  */
 
 using System;
@@ -44,14 +39,14 @@ namespace OpenSim.Region.Physics.BulletSPlugin
 {
 public class BSPrimDisplaced : BSPrim
 {
-    // The purpose of this module is to do any mapping between what the simulator thinks
+    // The purpose of this subclass is to do any mapping between what the simulator thinks
     //    the prim position and orientation is and what the physical position/orientation.
     //    This difference happens because Bullet assumes the center-of-mass is the <0,0,0>
-    //    of the prim/linkset. The simulator tracks the location of the prim/linkset by
-    //    the location of the root prim. So, if center-of-mass is anywhere but the origin
-    //    of the root prim, the physical origin is displaced from the simulator origin.
+    //    of the prim/linkset. The simulator, on the other hand, tracks the location of
+    //    the prim/linkset by the location of the root prim. So, if center-of-mass is anywhere
+    //    but the origin of the root prim, the physical origin is displaced from the simulator origin.
     //
-    // This routine works by capturing the Force* setting of position/orientation/... and
+    // This routine works by capturing ForcePosition and
     //    adjusting the simulator values (being set) into the physical values.
     //    The conversion is also done in the opposite direction (physical origin -> simulator origin).
     //
@@ -59,8 +54,8 @@ public class BSPrimDisplaced : BSPrim
     //    are converted into simulator origin values before being passed to the base
     //    class.
 
+    // PositionDisplacement is the vehicle relative distance from the root prim position to the center-of-mass.
     public virtual OMV.Vector3 PositionDisplacement { get; set; }
-    public virtual OMV.Quaternion OrientationDisplacement { get; set; }
 
     public BSPrimDisplaced(uint localID, String primName, BSScene parent_scene, OMV.Vector3 pos, OMV.Vector3 size,
                        OMV.Quaternion rotation, PrimitiveBaseShape pbs, bool pisPhysical)
@@ -69,68 +64,96 @@ public class BSPrimDisplaced : BSPrim
         ClearDisplacement();
     }
 
+    // Clears any center-of-mass displacement introduced by linksets, etc.
+    // Does not clear the displacement set by the user.
     public void ClearDisplacement()
     {
-        PositionDisplacement = OMV.Vector3.Zero;
-        OrientationDisplacement = OMV.Quaternion.Identity;
+        if (UserSetCenterOfMassDisplacement.HasValue)
+            PositionDisplacement = (OMV.Vector3)UserSetCenterOfMassDisplacement;
+        else
+            PositionDisplacement = OMV.Vector3.Zero;
     }
 
     // Set this sets and computes the displacement from the passed prim to the center-of-mass.
     // A user set value for center-of-mass overrides whatever might be passed in here.
     // The displacement is in local coordinates (relative to root prim in linkset oriented coordinates).
-    public virtual void SetEffectiveCenterOfMassW(Vector3 centerOfMassDisplacement)
+    // Returns the relative offset from the root position to the center-of-mass.
+    // Called at taint time.
+    public virtual Vector3 SetEffectiveCenterOfMassDisplacement(Vector3 centerOfMassDisplacement)
     {
+        PhysScene.AssertInTaintTime("BSPrimDisplaced.SetEffectiveCenterOfMassDisplacement");
         Vector3 comDisp;
-        if (UserSetCenterOfMass.HasValue)
-            comDisp = (OMV.Vector3)UserSetCenterOfMass;
+        if (UserSetCenterOfMassDisplacement.HasValue)
+            comDisp = (OMV.Vector3)UserSetCenterOfMassDisplacement;
         else
             comDisp = centerOfMassDisplacement;
 
-        if (comDisp == Vector3.Zero)
-        {
-            // If there is no diplacement. Things get reset.
-            PositionDisplacement = OMV.Vector3.Zero;
-            OrientationDisplacement = OMV.Quaternion.Identity;
-        }
-        else
+        // Eliminate any jitter caused be very slight differences in masses and positions
+        if (comDisp.ApproxEquals(Vector3.Zero, 0.01f) )
+            comDisp = Vector3.Zero;
+
+        DetailLog("{0},BSPrimDisplaced.SetEffectiveCenterOfMassDisplacement,userSet={1},comDisp={2}",
+                                    LocalID, UserSetCenterOfMassDisplacement.HasValue, comDisp);
+        if ( !comDisp.ApproxEquals(PositionDisplacement, 0.01f) )
         {
-            // Remember the displacement from root as well as the origional rotation of the
-            //    new center-of-mass.
+            // Displacement setting is changing.
+            // The relationship between the physical object and simulated object must be aligned.
             PositionDisplacement = comDisp;
-            OrientationDisplacement = OMV.Quaternion.Identity;
+            this.ForcePosition = RawPosition;
         }
+
+        return PositionDisplacement;
     }
 
+    // 'ForcePosition' is the one way to set the physical position of the body in the physics engine.
+    // Displace the simulator idea of position (center of root prim) to the physical position.
     public override Vector3 ForcePosition
     {
-        get { return base.ForcePosition; }
+        get {
+            OMV.Vector3 physPosition = PhysScene.PE.GetPosition(PhysBody);
+            if (PositionDisplacement != OMV.Vector3.Zero)
+            {
+                // If there is some displacement, return the physical position (center-of-mass)
+                //     location minus the displacement to give the center of the root prim.
+                OMV.Vector3 displacement = PositionDisplacement * ForceOrientation;
+                DetailLog("{0},BSPrimDisplaced.ForcePosition,get,physPos={1},disp={2},simPos={3}",
+                                LocalID, physPosition, displacement, physPosition - displacement);
+                physPosition -= displacement;
+            }
+            RawPosition = physPosition;
+            return physPosition;
+        }
         set
         {
             if (PositionDisplacement != OMV.Vector3.Zero)
-                base.ForcePosition = value - (PositionDisplacement * RawOrientation);
+            {
+                // This value is the simulator's idea of where the prim is: the center of the root prim
+                RawPosition = value;
+
+                // Move the passed root prim postion to the center-of-mass position and set in the physics engine.
+                OMV.Vector3 displacement = PositionDisplacement * RawOrientation;
+                OMV.Vector3 displacedPos = RawPosition + displacement;
+                DetailLog("{0},BSPrimDisplaced.ForcePosition,set,simPos={1},disp={2},physPos={3}",
+                                        LocalID, RawPosition, displacement, displacedPos);
+                if (PhysBody.HasPhysicalBody)
+                {
+                    PhysScene.PE.SetTranslation(PhysBody, displacedPos, RawOrientation);
+                    ActivateIfPhysical(false);
+                }
+            }
             else
+            {
                 base.ForcePosition = value;
+            }
         }
     }
 
-    public override Quaternion ForceOrientation
-    {
-        get { return base.ForceOrientation; }
-        set
-        {
-            base.ForceOrientation = value;
-        }
-    }
-
-    // TODO: decide if this is the right place for these variables.
-    //     Somehow incorporate the optional settability by the user.
-    // Is this used?
+    // These are also overridden by BSPrimLinkable if the prim can be part of a linkset
     public override OMV.Vector3 CenterOfMass
     {
         get { return RawPosition; }
     }
 
-    // Is this used?
     public override OMV.Vector3 GeometricCenter
     {
         get { return RawPosition; }
@@ -139,12 +162,18 @@ public class BSPrimDisplaced : BSPrim
     public override void UpdateProperties(EntityProperties entprop)
     {
         // Undo any center-of-mass displacement that might have been done.
-        if (PositionDisplacement != OMV.Vector3.Zero || OrientationDisplacement != OMV.Quaternion.Identity)
+        if (PositionDisplacement != OMV.Vector3.Zero)
         {
-            // Correct for any rotation around the center-of-mass
-            // TODO!!!
-            entprop.Position = entprop.Position + (PositionDisplacement * entprop.Rotation);
-            // entprop.Rotation = something;
+            // The origional shape was offset from 'zero' by PositionDisplacement.
+            // These physical location must be back converted to be centered around the displaced
+            //     root shape.
+
+            // Move the returned center-of-mass location to the root prim location.
+            OMV.Vector3 displacement = PositionDisplacement * entprop.Rotation;
+            OMV.Vector3 displacedPos = entprop.Position - displacement;
+            DetailLog("{0},BSPrimDisplaced.UpdateProperties,physPos={1},disp={2},simPos={3}",
+                                    LocalID, entprop.Position, displacement, displacedPos);
+            entprop.Position = displacedPos;
         }
 
         base.UpdateProperties(entprop);
diff --git a/OpenSim/Region/Physics/BulletSPlugin/BSPrimLinkable.cs b/OpenSim/Region/Physics/BulletSPlugin/BSPrimLinkable.cs
index d65d407..126b146 100755
--- a/OpenSim/Region/Physics/BulletSPlugin/BSPrimLinkable.cs
+++ b/OpenSim/Region/Physics/BulletSPlugin/BSPrimLinkable.cs
@@ -30,6 +30,7 @@ using System.Linq;
 using System.Text;
 
 using OpenSim.Framework;
+using OpenSim.Region.OptionalModules.Scripting;
 
 using OMV = OpenMetaverse;
 
@@ -37,44 +38,49 @@ namespace OpenSim.Region.Physics.BulletSPlugin
 {
 public class BSPrimLinkable : BSPrimDisplaced
 {
+    // The purpose of this subclass is to add linkset functionality to the prim. This overrides
+    //    operations necessary for keeping the linkset created and, additionally, this
+    //    calls the linkset implementation for its creation and management.
+
+    private static readonly string LogHeader = "[BULLETS PRIMLINKABLE]";
+
+    // This adds the overrides for link() and delink() so the prim is linkable.
+
     public BSLinkset Linkset { get; set; }
     // The index of this child prim.
     public int LinksetChildIndex { get; set; }
 
-    public BSLinksetInfo LinksetInfo { get; set; }
+    public BSLinkset.LinksetImplementation LinksetType { get; set; }
 
     public BSPrimLinkable(uint localID, String primName, BSScene parent_scene, OMV.Vector3 pos, OMV.Vector3 size,
                        OMV.Quaternion rotation, PrimitiveBaseShape pbs, bool pisPhysical)
         : base(localID, primName, parent_scene, pos, size, rotation, pbs, pisPhysical)
     {
-        Linkset = BSLinkset.Factory(PhysicsScene, this);
+        // Default linkset implementation for this prim
+        LinksetType = (BSLinkset.LinksetImplementation)BSParam.LinksetImplementation;
 
-        PhysicsScene.TaintedObject("BSPrimLinksetCompound.Refresh", delegate()
-        {
-            Linkset.Refresh(this);
-        });
+        Linkset = BSLinkset.Factory(PhysScene, this);
+
+        Linkset.Refresh(this);
     }
 
     public override void Destroy()
     {
-        Linkset = Linkset.RemoveMeFromLinkset(this);
+        Linkset = Linkset.RemoveMeFromLinkset(this, false /* inTaintTime */);
         base.Destroy();
     }
 
-    public override BSPhysicsShapeType PreferredPhysicalShape
-        { get { return Linkset.PreferredPhysicalShape(this); } }
-
     public override void link(Manager.PhysicsActor obj)
     {
         BSPrimLinkable parent = obj as BSPrimLinkable;
         if (parent != null)
         {
-            BSPhysObject parentBefore = Linkset.LinksetRoot;
-            int childrenBefore = Linkset.NumberOfChildren;
+            BSPhysObject parentBefore = Linkset.LinksetRoot;    // DEBUG
+            int childrenBefore = Linkset.NumberOfChildren;      // DEBUG
 
             Linkset = parent.Linkset.AddMeToLinkset(this);
 
-            DetailLog("{0},BSPrimLinkset.link,call,parentBefore={1}, childrenBefore=={2}, parentAfter={3}, childrenAfter={4}",
+            DetailLog("{0},BSPrimLinkable.link,call,parentBefore={1}, childrenBefore=={2}, parentAfter={3}, childrenAfter={4}",
                 LocalID, parentBefore.LocalID, childrenBefore, Linkset.LinksetRoot.LocalID, Linkset.NumberOfChildren);
         }
         return;
@@ -85,12 +91,12 @@ public class BSPrimLinkable : BSPrimDisplaced
         // TODO: decide if this parent checking needs to happen at taint time
         // Race condition here: if link() and delink() in same simulation tick, the delink will not happen
 
-        BSPhysObject parentBefore = Linkset.LinksetRoot;
-        int childrenBefore = Linkset.NumberOfChildren;
+        BSPhysObject parentBefore = Linkset.LinksetRoot;        // DEBUG
+        int childrenBefore = Linkset.NumberOfChildren;          // DEBUG
 
-        Linkset = Linkset.RemoveMeFromLinkset(this);
+        Linkset = Linkset.RemoveMeFromLinkset(this, false /* inTaintTime*/);
 
-        DetailLog("{0},BSPrimLinkset.delink,parentBefore={1},childrenBefore={2},parentAfter={3},childrenAfter={4}, ",
+        DetailLog("{0},BSPrimLinkable.delink,parentBefore={1},childrenBefore={2},parentAfter={3},childrenAfter={4}, ",
             LocalID, parentBefore.LocalID, childrenBefore, Linkset.LinksetRoot.LocalID, Linkset.NumberOfChildren);
         return;
     }
@@ -102,7 +108,7 @@ public class BSPrimLinkable : BSPrimDisplaced
         set
         {
             base.Position = value;
-            PhysicsScene.TaintedObject("BSPrimLinkset.setPosition", delegate()
+            PhysScene.TaintedObject(LocalID, "BSPrimLinkable.setPosition", delegate()
             {
                 Linkset.UpdateProperties(UpdatedProperties.Position, this);
             });
@@ -116,7 +122,7 @@ public class BSPrimLinkable : BSPrimDisplaced
         set
         {
             base.Orientation = value;
-            PhysicsScene.TaintedObject("BSPrimLinkset.setOrientation", delegate()
+            PhysScene.TaintedObject(LocalID, "BSPrimLinkable.setOrientation", delegate()
             {
                 Linkset.UpdateProperties(UpdatedProperties.Orientation, this);
             });
@@ -128,6 +134,17 @@ public class BSPrimLinkable : BSPrimDisplaced
         get { return Linkset.LinksetMass; }
     }
 
+    public override OMV.Vector3 CenterOfMass
+    {
+        get { return Linkset.CenterOfMass; }
+    }
+
+    public override OMV.Vector3 GeometricCenter
+    {
+        get { return Linkset.GeometricCenter; }
+    }
+
+    // Refresh the linkset structure and parameters when the prim's physical parameters are changed.
     public override void UpdatePhysicalParameters()
     {
         base.UpdatePhysicalParameters();
@@ -139,44 +156,193 @@ public class BSPrimLinkable : BSPrimDisplaced
             Linkset.Refresh(this);
     }
 
+    // When the prim is made dynamic or static, the linkset needs to change.
     protected override void MakeDynamic(bool makeStatic)
     {
         base.MakeDynamic(makeStatic);
-        if (makeStatic)
-            Linkset.MakeStatic(this);
-        else
-            Linkset.MakeDynamic(this);
+        if (Linkset != null)    // null can happen during initialization
+        {
+            if (makeStatic)
+                Linkset.MakeStatic(this);
+            else
+                Linkset.MakeDynamic(this);
+        }
     }
 
     // Body is being taken apart. Remove physical dependencies and schedule a rebuild.
-    protected override void RemoveBodyDependencies()
+    protected override void RemoveDependencies()
     {
-        Linkset.RemoveBodyDependencies(this);
-        base.RemoveBodyDependencies();
+        Linkset.RemoveDependencies(this);
+        base.RemoveDependencies();
     }
 
+    // Called after a simulation step for the changes in physical object properties.
+    // Do any filtering/modification needed for linksets.
     public override void UpdateProperties(EntityProperties entprop)
     {
-        if (Linkset.IsRoot(this))
+        if (Linkset.IsRoot(this) || Linkset.ShouldReportPropertyUpdates(this))
         {
             // Properties are only updated for the roots of a linkset.
             // TODO: this will have to change when linksets are articulated.
             base.UpdateProperties(entprop);
         }
+            /*
+        else
+        {
+            // For debugging, report the movement of children
+            DetailLog("{0},BSPrim.UpdateProperties,child,pos={1},orient={2},vel={3},accel={4},rotVel={5}",
+                    LocalID, entprop.Position, entprop.Rotation, entprop.Velocity,
+                    entprop.Acceleration, entprop.RotationalVelocity);
+        }
+             */
         // The linkset might like to know about changing locations
         Linkset.UpdateProperties(UpdatedProperties.EntPropUpdates, this);
     }
 
+    // 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))
+        {
+            // The linkset didn't handle it so pass the collision through normal processing
+            ret = base.Collide(collidingWith, collidee, contactPoint, contactNormal, pentrationDepth);
+        }
+        return ret;
+    }
+
+    // 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
         {
-            return false;
+            if (value)
+                SomeCollisionSimulationStep = PhysScene.SimulationStep;
+            else
+                SomeCollisionSimulationStep = 0;
+
+            base.HasSomeCollision = value;
+        }
+    }
+
+    // Convert the existing linkset of this prim into a new type.
+    public bool ConvertLinkset(BSLinkset.LinksetImplementation newType)
+    {
+        bool ret = false;
+        if (LinksetType != newType)
+        {
+            DetailLog("{0},BSPrimLinkable.ConvertLinkset,oldT={1},newT={2}", LocalID, LinksetType, newType);
+
+            // Set the implementation type first so the call to BSLinkset.Factory gets the new type.
+            this.LinksetType = newType;
+
+            BSLinkset oldLinkset = this.Linkset;
+            BSLinkset newLinkset = BSLinkset.Factory(PhysScene, this);
+
+            this.Linkset = newLinkset;
+
+            // Pick up any physical dependencies this linkset might have in the physics engine.
+            oldLinkset.RemoveDependencies(this);
+
+            // Create a list of the children (mainly because can't interate through a list that's changing)
+            List<BSPrimLinkable> children = new List<BSPrimLinkable>();
+            oldLinkset.ForEachMember((child) =>
+            {
+                if (!oldLinkset.IsRoot(child))
+                    children.Add(child);
+                return false;   // 'false' says to continue to next member
+            });
+
+            // Remove the children from the old linkset and add to the new (will be a new instance from the factory)
+            foreach (BSPrimLinkable child in children)
+            {
+                oldLinkset.RemoveMeFromLinkset(child, true /*inTaintTime*/);
+            }
+            foreach (BSPrimLinkable child in children)
+            {
+                newLinkset.AddMeToLinkset(child);
+                child.Linkset = newLinkset;
+            }
+
+            // Force the shape and linkset to get reconstructed
+            newLinkset.Refresh(this);
+            this.ForceBodyShapeRebuild(true /* inTaintTime */);
+        }
+        return ret;
+    }
+
+    #region Extension
+    public override object Extension(string pFunct, params object[] pParams)
+    {
+        DetailLog("{0} BSPrimLinkable.Extension,op={1},nParam={2}", LocalID, pFunct, pParams.Length);
+        object ret = null;
+        switch (pFunct)
+        {
+            // physGetLinksetType();
+            // pParams = [ BSPhysObject root, null ]
+            case ExtendedPhysics.PhysFunctGetLinksetType:
+            {
+                ret = (object)LinksetType;
+                DetailLog("{0},BSPrimLinkable.Extension.physGetLinksetType,type={1}", LocalID, ret);
+                break;
+            }
+            // physSetLinksetType(type);
+            // pParams = [ BSPhysObject root, null, integer type ]
+            case ExtendedPhysics.PhysFunctSetLinksetType:
+            {
+                if (pParams.Length > 2)
+                {
+                    BSLinkset.LinksetImplementation linksetType = (BSLinkset.LinksetImplementation)pParams[2];
+                    if (Linkset.IsRoot(this))
+                    {
+                        PhysScene.TaintedObject(LocalID, "BSPrim.PhysFunctSetLinksetType", delegate()
+                        {
+                            // Cause the linkset type to change
+                            DetailLog("{0},BSPrimLinkable.Extension.physSetLinksetType, oldType={1},newType={2}",
+                                                LocalID, Linkset.LinksetImpl, linksetType);
+                            ConvertLinkset(linksetType);
+                        });
+                    }
+                    ret = (object)(int)linksetType;
+                }
+                break;
+            }
+            // physChangeLinkType(linknum, typeCode);
+            // pParams = [ BSPhysObject root, BSPhysObject child, integer linkType ]
+            case ExtendedPhysics.PhysFunctChangeLinkType:
+            {
+                ret = Linkset.Extension(pFunct, pParams);
+                break;
+            }
+            // physGetLinkType(linknum);
+            // pParams = [ BSPhysObject root, BSPhysObject child ]
+            case ExtendedPhysics.PhysFunctGetLinkType:
+            {
+                ret = Linkset.Extension(pFunct, pParams);
+                break;
+            }
+            // physChangeLinkParams(linknum, [code, value, code, value, ...]);
+            // pParams = [ BSPhysObject root, BSPhysObject child, object[] [ string op, object opParam, string op, object opParam, ... ] ]
+            case ExtendedPhysics.PhysFunctChangeLinkParams:
+            {
+                ret = Linkset.Extension(pFunct, pParams);
+                break;
+            }
+            default:
+                ret = base.Extension(pFunct, pParams);
+                break;
         }
-        return base.Collide(collidingWith, collidee, contactPoint, contactNormal, pentrationDepth);
+        return ret;
     }
+    #endregion  // Extension
 }
 }
diff --git a/OpenSim/Region/Physics/BulletSPlugin/BSScene.cs b/OpenSim/Region/Physics/BulletSPlugin/BSScene.cs
index e6aefd5..b3dfa41 100644
--- a/OpenSim/Region/Physics/BulletSPlugin/BSScene.cs
+++ b/OpenSim/Region/Physics/BulletSPlugin/BSScene.cs
@@ -1,4 +1,4 @@
-/*
+/*
  * Copyright (c) Contributors, http://opensimulator.org/
  * See CONTRIBUTORS.TXT for a full list of copyright holders.
  *
@@ -56,12 +56,23 @@ public sealed class BSScene : PhysicsScene, IPhysicsParameters
     public string BulletEngineName { get; private set; }
     public BSAPITemplate PE;
 
+    // If the physics engine is running on a separate thread
+    public Thread m_physicsThread;
+
     public Dictionary<uint, BSPhysObject> PhysObjects;
     public BSShapeCollection Shapes;
 
     // Keeping track of the objects with collisions so we can report begin and end of a collision
     public HashSet<BSPhysObject> ObjectsWithCollisions = new HashSet<BSPhysObject>();
     public HashSet<BSPhysObject> ObjectsWithNoMoreCollisions = new HashSet<BSPhysObject>();
+
+    // All the collision processing is protected with this lock object
+    public Object CollisionLock = new Object();
+
+    // Properties are updated here
+    public Object UpdateLock = new Object();
+    public HashSet<BSPhysObject> ObjectsWithUpdates = new HashSet<BSPhysObject>();
+
     // Keep track of all the avatars so we can send them a collision event
     //    every tick so OpenSim will update its animation.
     private HashSet<BSPhysObject> m_avatars = new HashSet<BSPhysObject>();
@@ -77,12 +88,22 @@ public sealed class BSScene : PhysicsScene, IPhysicsParameters
     public BSConstraintCollection Constraints { get; private set; }
 
     // Simulation parameters
+    internal float m_physicsStepTime;   // if running independently, the interval simulated by default
+
     internal int m_maxSubSteps;
     internal float m_fixedTimeStep;
-    internal long m_simulationStep = 0;
-    internal float NominalFrameRate { get; set; }
+
+    internal float m_simulatedTime;     // the time simulated previously. Used for physics framerate calc.
+
+    internal long m_simulationStep = 0; // The current simulation step.
     public long SimulationStep { get { return m_simulationStep; } }
-    internal float LastTimeStep { get; private set; }
+    // A number to use for SimulationStep that is probably not any step value
+    // Used by the collision code (which remembers the step when a collision happens) to remember not any simulation step.
+    public static long NotASimulationStep = -1234;
+
+    internal float LastTimeStep { get; private set; }   // The simulation time from the last invocation of Simulate()
+
+    internal float NominalFrameRate { get; set; }       // Parameterized ideal frame rate that simulation is scaled to
 
     // Physical objects can register for prestep or poststep events
     public delegate void PreStepAction(float timeStep);
@@ -90,7 +111,7 @@ public sealed class BSScene : PhysicsScene, IPhysicsParameters
     public event PreStepAction BeforeStep;
     public event PostStepAction AfterStep;
 
-    // A value of the time now so all the collision and update routines do not have to get their own
+    // A value of the time 'now' so all the collision and update routines do not have to get their own
     // Set to 'now' just before all the prims and actors are called for collisions and updates
     public int SimulationNowTime { get; private set; }
 
@@ -136,12 +157,20 @@ public sealed class BSScene : PhysicsScene, IPhysicsParameters
     public delegate void TaintCallback();
     private struct TaintCallbackEntry
     {
+        public String originator;
         public String ident;
         public TaintCallback callback;
-        public TaintCallbackEntry(string i, TaintCallback c)
+        public TaintCallbackEntry(string pIdent, TaintCallback pCallBack)
+        {
+            originator = BSScene.DetailLogZero;
+            ident = pIdent;
+            callback = pCallBack;
+        }
+        public TaintCallbackEntry(string pOrigin, string pIdent, TaintCallback pCallBack)
         {
-            ident = i;
-            callback = c;
+            originator = pOrigin;
+            ident = pIdent;
+            callback = pCallBack;
         }
     }
     private Object _taintLock = new Object();   // lock for using the next object
@@ -188,6 +217,9 @@ public sealed class BSScene : PhysicsScene, IPhysicsParameters
         PhysObjects = new Dictionary<uint, BSPhysObject>();
         Shapes = new BSShapeCollection(this);
 
+        m_simulatedTime = 0f;
+        LastTimeStep = 0.1f;
+
         // Allocate pinned memory to pass parameters.
         UnmanagedParams = new ConfigurationParameters[1];
 
@@ -202,8 +234,8 @@ public sealed class BSScene : PhysicsScene, IPhysicsParameters
         //     can be left in and every call doesn't have to check for null.
         if (m_physicsLoggingEnabled)
         {
-            PhysicsLogging = new Logging.LogWriter(m_physicsLoggingDir, m_physicsLoggingPrefix, m_physicsLoggingFileMinutes);
-            PhysicsLogging.ErrorLogger = m_log; // for DEBUG. Let's the logger output error messages.
+            PhysicsLogging = new Logging.LogWriter(m_physicsLoggingDir, m_physicsLoggingPrefix, m_physicsLoggingFileMinutes, m_physicsLoggingDoFlush);
+            PhysicsLogging.ErrorLogger = m_log; // for DEBUG. Let's the logger output its own error messages.
         }
         else
         {
@@ -227,10 +259,20 @@ public sealed class BSScene : PhysicsScene, IPhysicsParameters
         TerrainManager = new BSTerrainManager(this);
         TerrainManager.CreateInitialGroundPlaneAndTerrain();
 
-        m_log.WarnFormat("{0} Linksets implemented with {1}", LogHeader, (BSLinkset.LinksetImplementation)BSParam.LinksetImplementation);
+        // Put some informational messages into the log file.
+        m_log.InfoFormat("{0} Linksets implemented with {1}", LogHeader, (BSLinkset.LinksetImplementation)BSParam.LinksetImplementation);
 
         InTaintTime = false;
         m_initialized = true;
+
+        // If the physics engine runs on its own thread, start same.
+        if (BSParam.UseSeparatePhysicsThread)
+        {
+            // The physics simulation should happen independently of the heartbeat loop
+            m_physicsThread = new Thread(BulletSPluginPhysicsThread);
+            m_physicsThread.Name = BulletEngineName;
+            m_physicsThread.Start();
+        }
     }
 
     // All default parameter values are set here. There should be no values set in the
@@ -268,6 +310,13 @@ public sealed class BSScene : PhysicsScene, IPhysicsParameters
                 // Do any replacements in the parameters
                 m_physicsLoggingPrefix = m_physicsLoggingPrefix.Replace("%REGIONNAME%", RegionName);
             }
+            else
+            {
+                // Nothing in the configuration INI file so assume unmanaged and other defaults.
+                BulletEngineName = "BulletUnmanaged";
+                m_physicsLoggingEnabled = false;
+                VehicleLoggingEnabled = false;
+            }
 
             // The material characteristics.
             BSMaterials.InitializeFromDefaults(Params);
@@ -311,11 +360,22 @@ public sealed class BSScene : PhysicsScene, IPhysicsParameters
 
         switch (selectionName)
         {
+            case "bullet":
             case "bulletunmanaged":
                 ret = new BSAPIUnman(engineName, this);
                 break;
             case "bulletxna":
                 ret = new BSAPIXNA(engineName, this);
+                // Disable some features that are not implemented in BulletXNA
+                m_log.InfoFormat("{0} Disabling some physics features not implemented by BulletXNA", LogHeader);
+                m_log.InfoFormat("{0}    Disabling ShouldUseBulletHACD", LogHeader);
+                BSParam.ShouldUseBulletHACD = false;
+                m_log.InfoFormat("{0}    Disabling ShouldUseSingleConvexHullForPrims", LogHeader);
+                BSParam.ShouldUseSingleConvexHullForPrims = false;
+                m_log.InfoFormat("{0}    Disabling ShouldUseGImpactShapeForPrims", LogHeader);
+                BSParam.ShouldUseGImpactShapeForPrims = false;
+                m_log.InfoFormat("{0}    Setting terrain implimentation to Heightmap", LogHeader);
+                BSParam.TerrainImplementation = (float)BSTerrainPhys.TerrainImplementation.Heightmap;
                 break;
         }
 
@@ -325,7 +385,7 @@ public sealed class BSScene : PhysicsScene, IPhysicsParameters
         }
         else
         {
-            m_log.WarnFormat("{0} Selected bullet engine {1} -> {2}/{3}", LogHeader, engineName, ret.BulletEngineName, ret.BulletEngineVersion);
+            m_log.InfoFormat("{0} Selected bullet engine {1} -> {2}/{3}", LogHeader, engineName, ret.BulletEngineName, ret.BulletEngineVersion);
         }
 
         return ret;
@@ -463,7 +523,7 @@ public sealed class BSScene : PhysicsScene, IPhysicsParameters
 
         if (!m_initialized) return null;
 
-        DetailLog("{0},BSScene.AddPrimShape,call", localID);
+        // DetailLog("{0},BSScene.AddPrimShape,call", localID);
 
         BSPhysObject prim = new BSPrimLinkable(localID, primName, this, position, size, rotation, pbs, isPhysical);
         lock (PhysObjects) PhysObjects.Add(localID, prim);
@@ -478,25 +538,41 @@ public sealed class BSScene : PhysicsScene, IPhysicsParameters
     #endregion // Prim and Avatar addition and removal
 
     #region Simulation
-    // Simulate one timestep
+
+    // Call from the simulator to send physics information to the simulator objects.
+    // This pushes all the collision and property update events into the objects in
+    //    the simulator and, since it is on the heartbeat thread, there is an implicit
+    //    locking of those data structures from other heartbeat events.
+    // If the physics engine is running on a separate thread, the update information
+    //    will be in the ObjectsWithCollions and ObjectsWithUpdates structures.
     public override float Simulate(float timeStep)
     {
+        if (!BSParam.UseSeparatePhysicsThread)
+        {
+            DoPhysicsStep(timeStep);
+        }
+        return SendUpdatesToSimulator(timeStep);
+    }
+
+    // Call the physics engine to do one 'timeStep' and collect collisions and updates
+    //    into ObjectsWithCollisions and ObjectsWithUpdates data structures.
+    private void DoPhysicsStep(float timeStep)
+    {
         // prevent simulation until we've been initialized
-        if (!m_initialized) return 5.0f;
+        if (!m_initialized) return;
 
         LastTimeStep = timeStep;
 
         int updatedEntityCount = 0;
         int collidersCount = 0;
 
-        int beforeTime = 0;
+        int beforeTime = Util.EnvironmentTickCount();
         int simTime = 0;
 
-        // update the prim states while we know the physics engine is not busy
         int numTaints = _taintOperations.Count;
-
         InTaintTime = true; // Only used for debugging so locking is not necessary.
 
+        // update the prim states while we know the physics engine is not busy
         ProcessTaints();
 
         // Some of the physical objects requre individual, pre-step calls
@@ -519,18 +595,8 @@ public sealed class BSScene : PhysicsScene, IPhysicsParameters
         int numSubSteps = 0;
         try
         {
-            if (PhysicsLogging.Enabled)
-                beforeTime = Util.EnvironmentTickCount();
-
             numSubSteps = PE.PhysicsStep(World, timeStep, m_maxSubSteps, m_fixedTimeStep, out updatedEntityCount, out collidersCount);
 
-            if (PhysicsLogging.Enabled)
-            {
-                simTime = Util.EnvironmentTickCountSubtract(beforeTime);
-                DetailLog("{0},Simulate,call, frame={1}, nTaints={2}, simTime={3}, substeps={4}, updates={5}, colliders={6}, objWColl={7}",
-                                        DetailLogZero, m_simulationStep, numTaints, simTime, numSubSteps,
-                                        updatedEntityCount, collidersCount, ObjectsWithCollisions.Count);
-            }
         }
         catch (Exception e)
         {
@@ -542,77 +608,63 @@ public sealed class BSScene : PhysicsScene, IPhysicsParameters
             collidersCount = 0;
         }
 
+        // Make the physics engine dump useful statistics periodically
         if (PhysicsMetricDumpFrames != 0 && ((m_simulationStep % PhysicsMetricDumpFrames) == 0))
             PE.DumpPhysicsStatistics(World);
 
         // Get a value for 'now' so all the collision and update routines don't have to get their own.
         SimulationNowTime = Util.EnvironmentTickCount();
 
-        // If there were collisions, process them by sending the event to the prim.
-        // Collisions must be processed before updates.
-        if (collidersCount > 0)
+        // Send collision information to the colliding objects. The objects decide if the collision
+        //     is 'real' (like linksets don't collide with themselves) and the individual objects
+        //     know if the simulator has subscribed to collisions.
+        lock (CollisionLock)
         {
-            for (int ii = 0; ii < collidersCount; ii++)
+            if (collidersCount > 0)
             {
-                uint cA = m_collisionArray[ii].aID;
-                uint cB = m_collisionArray[ii].bID;
-                Vector3 point = m_collisionArray[ii].point;
-                Vector3 normal = m_collisionArray[ii].normal;
-                float penetration = m_collisionArray[ii].penetration;
-                SendCollision(cA, cB, point, normal, penetration);
-                SendCollision(cB, cA, point, -normal, penetration);
-            }
-        }
-
-        // The above SendCollision's batch up the collisions on the objects.
-        //      Now push the collisions into the simulator.
-        if (ObjectsWithCollisions.Count > 0)
-        {
-            foreach (BSPhysObject bsp in ObjectsWithCollisions)
-                if (!bsp.SendCollisions())
+                for (int ii = 0; ii < collidersCount; ii++)
                 {
-                    // If the object is done colliding, see that it's removed from the colliding list
-                    ObjectsWithNoMoreCollisions.Add(bsp);
+                    uint cA = m_collisionArray[ii].aID;
+                    uint cB = m_collisionArray[ii].bID;
+                    Vector3 point = m_collisionArray[ii].point;
+                    Vector3 normal = m_collisionArray[ii].normal;
+                    float penetration = m_collisionArray[ii].penetration;
+                    SendCollision(cA, cB, point, normal, penetration);
+                    SendCollision(cB, cA, point, -normal, penetration);
                 }
+            }
         }
 
-        // This is a kludge to get avatar movement updates.
-        // The simulator expects collisions for avatars even if there are have been no collisions.
-        //    The event updates avatar animations and stuff.
-        // If you fix avatar animation updates, remove this overhead and let normal collision processing happen.
-        foreach (BSPhysObject bsp in m_avatars)
-            if (!ObjectsWithCollisions.Contains(bsp))   // don't call avatars twice
-                bsp.SendCollisions();
-
-        // Objects that are done colliding are removed from the ObjectsWithCollisions list.
-        // Not done above because it is inside an iteration of ObjectWithCollisions.
-        // This complex collision processing is required to create an empty collision
-        //     event call after all real collisions have happened on an object. This enables
-        //     the simulator to generate the 'collision end' event.
-        if (ObjectsWithNoMoreCollisions.Count > 0)
-        {
-            foreach (BSPhysObject po in ObjectsWithNoMoreCollisions)
-                ObjectsWithCollisions.Remove(po);
-            ObjectsWithNoMoreCollisions.Clear();
-        }
-        // Done with collisions.
-
-        // If any of the objects had updated properties, tell the object it has been changed by the physics engine
-        if (updatedEntityCount > 0)
+        // If any of the objects had updated properties, tell the managed objects about the update
+        //     and remember that there was a change so it will be passed to the simulator.
+        lock (UpdateLock)
         {
-            for (int ii = 0; ii < updatedEntityCount; ii++)
+            if (updatedEntityCount > 0)
             {
-                EntityProperties entprop = m_updateArray[ii];
-                BSPhysObject pobj;
-                if (PhysObjects.TryGetValue(entprop.ID, out pobj))
+                for (int ii = 0; ii < updatedEntityCount; ii++)
                 {
-                    pobj.UpdateProperties(entprop);
+                    EntityProperties entprop = m_updateArray[ii];
+                    BSPhysObject pobj;
+                    if (PhysObjects.TryGetValue(entprop.ID, out pobj))
+                    {
+                        if (pobj.IsInitialized)
+                            pobj.UpdateProperties(entprop);
+                    }
                 }
             }
         }
 
+        // Some actors want to know when the simulation step is complete.
         TriggerPostStepEvent(timeStep);
 
+        simTime = Util.EnvironmentTickCountSubtract(beforeTime);
+        if (PhysicsLogging.Enabled)
+        {
+            DetailLog("{0},DoPhysicsStep,complete,frame={1}, nTaints={2}, simTime={3}, substeps={4}, updates={5}, colliders={6}, objWColl={7}",
+                                    DetailLogZero, m_simulationStep, numTaints, simTime, numSubSteps,
+                                    updatedEntityCount, collidersCount, ObjectsWithCollisions.Count);
+        }
+
         // The following causes the unmanaged code to output ALL the values found in ALL the objects in the world.
         // Only enable this in a limited test world with few objects.
         if (m_physicsPhysicalDumpEnabled)
@@ -621,7 +673,84 @@ public sealed class BSScene : PhysicsScene, IPhysicsParameters
         // The physics engine returns the number of milliseconds it simulated this call.
         // These are summed and normalized to one second and divided by 1000 to give the reported physics FPS.
         // Multiply by a fixed nominal frame rate to give a rate similar to the simulator (usually 55).
-        return (float)numSubSteps * m_fixedTimeStep * 1000f * NominalFrameRate;
+        m_simulatedTime +=  (float)numSubSteps * m_fixedTimeStep * 1000f * NominalFrameRate;
+    }
+
+    // Called by a BSPhysObject to note that it has changed properties and this information
+    //    should be passed up to the simulator at the proper time.
+    // Note: this is called by the BSPhysObject from invocation via DoPhysicsStep() above so
+    //    this is is under UpdateLock.
+    public void PostUpdate(BSPhysObject updatee)
+    {
+        ObjectsWithUpdates.Add(updatee);
+    }
+
+    // The simulator thinks it is physics time so return all the collisions and position
+    //     updates that were collected in actual physics simulation.
+    private float SendUpdatesToSimulator(float timeStep)
+    {
+        if (!m_initialized) return 5.0f;
+
+        DetailLog("{0},SendUpdatesToSimulator,collisions={1},updates={2},simedTime={3}",
+            BSScene.DetailLogZero, ObjectsWithCollisions.Count, ObjectsWithUpdates.Count, m_simulatedTime);
+        // Push the collisions into the simulator.
+        lock (CollisionLock)
+        {
+            if (ObjectsWithCollisions.Count > 0)
+            {
+                foreach (BSPhysObject bsp in ObjectsWithCollisions)
+                    if (!bsp.SendCollisions())
+                    {
+                        // If the object is done colliding, see that it's removed from the colliding list
+                        ObjectsWithNoMoreCollisions.Add(bsp);
+                    }
+            }
+
+            // This is a kludge to get avatar movement updates.
+            // The simulator expects collisions for avatars even if there are have been no collisions.
+            //    The event updates avatar animations and stuff.
+            // If you fix avatar animation updates, remove this overhead and let normal collision processing happen.
+            foreach (BSPhysObject bsp in m_avatars)
+                if (!ObjectsWithCollisions.Contains(bsp))   // don't call avatars twice
+                    bsp.SendCollisions();
+
+            // Objects that are done colliding are removed from the ObjectsWithCollisions list.
+            // Not done above because it is inside an iteration of ObjectWithCollisions.
+            // This complex collision processing is required to create an empty collision
+            //     event call after all real collisions have happened on an object. This allows
+            //     the simulator to generate the 'collision end' event.
+            if (ObjectsWithNoMoreCollisions.Count > 0)
+            {
+                foreach (BSPhysObject po in ObjectsWithNoMoreCollisions)
+                    ObjectsWithCollisions.Remove(po);
+                ObjectsWithNoMoreCollisions.Clear();
+            }
+        }
+
+        // Call the simulator for each object that has physics property updates.
+        HashSet<BSPhysObject> updatedObjects = null;
+        lock (UpdateLock)
+        {
+            if (ObjectsWithUpdates.Count > 0)
+            {
+                updatedObjects = ObjectsWithUpdates;
+                ObjectsWithUpdates = new HashSet<BSPhysObject>();
+            }
+        }
+        if (updatedObjects != null)
+        {
+            foreach (BSPhysObject obj in updatedObjects)
+            {
+                obj.RequestPhysicsterseUpdate();
+            }
+            updatedObjects.Clear();
+        }
+
+        // Return the framerate simulated to give the above returned results.
+        // (Race condition here but this is just bookkeeping so rare mistakes do not merit a lock).
+        float simTime = m_simulatedTime;
+        m_simulatedTime = 0f;
+        return simTime;
     }
 
     // Something has collided
@@ -640,21 +769,49 @@ public sealed class BSScene : PhysicsScene, IPhysicsParameters
             return;
         }
 
-        // The terrain is not in the physical object list so 'collidee' can be null when Collide() is called.
+        // Note: the terrain is not in the physical object list so 'collidee' can be null when Collide() is called.
         BSPhysObject collidee = null;
         PhysObjects.TryGetValue(collidingWith, out collidee);
 
         // DetailLog("{0},BSScene.SendCollision,collide,id={1},with={2}", DetailLogZero, localID, collidingWith);
 
-        if (collider.Collide(collidingWith, collidee, collidePoint, collideNormal, penetration))
+        if (collider.IsInitialized)
         {
-            // If a collision was posted, remember to send it to the simulator
-            ObjectsWithCollisions.Add(collider);
+            if (collider.Collide(collidingWith, collidee, collidePoint, collideNormal, penetration))
+            {
+                // If a collision was 'good', remember to send it to the simulator
+                ObjectsWithCollisions.Add(collider);
+            }
         }
 
         return;
     }
 
+    public void BulletSPluginPhysicsThread()
+    {
+        while (m_initialized)
+        {
+            int beginSimulationRealtimeMS = Util.EnvironmentTickCount();
+            DoPhysicsStep(BSParam.PhysicsTimeStep);
+            int simulationRealtimeMS = Util.EnvironmentTickCountSubtract(beginSimulationRealtimeMS);
+            int simulationTimeVsRealtimeDifferenceMS = ((int)(BSParam.PhysicsTimeStep*1000f)) - simulationRealtimeMS;
+
+            if (simulationTimeVsRealtimeDifferenceMS > 0)
+            {
+                // The simulation of the time interval took less than realtime.
+                // Do a sleep for the rest of realtime.
+                Thread.Sleep(simulationTimeVsRealtimeDifferenceMS);
+            }
+            else
+            {
+                // The simulation took longer than realtime.
+                // Do some scaling of simulation time.
+                // TODO.
+                DetailLog("{0},BulletSPluginPhysicsThread,longerThanRealtime={1}", BSScene.DetailLogZero, simulationTimeVsRealtimeDifferenceMS);
+            }
+        }
+    }
+
     #endregion // Simulation
 
     public override void GetResults() { }
@@ -717,6 +874,14 @@ public sealed class BSScene : PhysicsScene, IPhysicsParameters
 
     public override bool IsThreaded { get { return false;  } }
 
+    #region Extensions
+    public override object Extension(string pFunct, params object[] pParams)
+    {
+        DetailLog("{0} BSScene.Extension,op={1}", DetailLogZero, pFunct);
+        return base.Extension(pFunct, pParams);
+    }
+    #endregion // Extensions
+
     #region Taints
     // The simulation execution order is:
     // Simulate()
@@ -731,26 +896,37 @@ public sealed class BSScene : PhysicsScene, IPhysicsParameters
     // Calls to the PhysicsActors can't directly call into the physics engine
     //       because it might be busy. We delay changes to a known time.
     // We rely on C#'s closure to save and restore the context for the delegate.
-    public void TaintedObject(String ident, TaintCallback callback)
+    public void TaintedObject(string pOriginator, string pIdent, TaintCallback pCallback)
     {
-        if (!m_initialized) return;
-
-        lock (_taintLock)
-        {
-            _taintOperations.Add(new TaintCallbackEntry(ident, callback));
-        }
-
-        return;
+        TaintedObject(false /*inTaintTime*/, pOriginator, pIdent, pCallback);
+    }
+    public void TaintedObject(uint pOriginator, String pIdent, TaintCallback pCallback)
+    {
+        TaintedObject(false /*inTaintTime*/, m_physicsLoggingEnabled ? pOriginator.ToString() : BSScene.DetailLogZero, pIdent, pCallback);
+    }
+    public void TaintedObject(bool inTaintTime, String pIdent, TaintCallback pCallback)
+    {
+        TaintedObject(inTaintTime, BSScene.DetailLogZero, pIdent, pCallback);
+    }
+    public void TaintedObject(bool inTaintTime, uint pOriginator, String pIdent, TaintCallback pCallback)
+    {
+        TaintedObject(inTaintTime, m_physicsLoggingEnabled ? pOriginator.ToString() : BSScene.DetailLogZero, pIdent, pCallback);
     }
-
     // Sometimes a potentially tainted operation can be used in and out of taint time.
     // This routine executes the command immediately if in taint-time otherwise it is queued.
-    public void TaintedObject(bool inTaintTime, string ident, TaintCallback callback)
+    public void TaintedObject(bool inTaintTime, string pOriginator, string pIdent, TaintCallback pCallback)
     {
+        if (!m_initialized) return;
+
         if (inTaintTime)
-            callback();
+            pCallback();
         else
-            TaintedObject(ident, callback);
+        {
+            lock (_taintLock)
+            {
+                _taintOperations.Add(new TaintCallbackEntry(pOriginator, pIdent, pCallback));
+            }
+        }
     }
 
     private void TriggerPreStepEvent(float timeStep)
@@ -780,7 +956,7 @@ public sealed class BSScene : PhysicsScene, IPhysicsParameters
 
     private void ProcessRegularTaints()
     {
-        if (_taintOperations.Count > 0)  // save allocating new list if there is nothing to process
+        if (m_initialized && _taintOperations.Count > 0)  // save allocating new list if there is nothing to process
         {
             // swizzle a new list into the list location so we can process what's there
             List<TaintCallbackEntry> oldList;
@@ -794,7 +970,7 @@ public sealed class BSScene : PhysicsScene, IPhysicsParameters
             {
                 try
                 {
-                    DetailLog("{0},BSScene.ProcessTaints,doTaint,id={1}", DetailLogZero, tcbe.ident); // DEBUG DEBUG DEBUG
+                    DetailLog("{0},BSScene.ProcessTaints,doTaint,id={1}", tcbe.originator, tcbe.ident); // DEBUG DEBUG DEBUG
                     tcbe.callback();
                 }
                 catch (Exception e)
@@ -811,10 +987,11 @@ public sealed class BSScene : PhysicsScene, IPhysicsParameters
     //     will replace any previous operation by the same object.
     public void PostTaintObject(String ident, uint ID, TaintCallback callback)
     {
-        string uniqueIdent = ident + "-" + ID.ToString();
+        string IDAsString = ID.ToString();
+        string uniqueIdent = ident + "-" + IDAsString;
         lock (_taintLock)
         {
-            _postTaintOperations[uniqueIdent] = new TaintCallbackEntry(uniqueIdent, callback);
+            _postTaintOperations[uniqueIdent] = new TaintCallbackEntry(IDAsString, uniqueIdent, callback);
         }
 
         return;
@@ -823,7 +1000,7 @@ public sealed class BSScene : PhysicsScene, IPhysicsParameters
     // Taints that happen after the normal taint processing but before the simulation step.
     private void ProcessPostTaintTaints()
     {
-        if (_postTaintOperations.Count > 0)
+        if (m_initialized && _postTaintOperations.Count > 0)
         {
             Dictionary<string, TaintCallbackEntry> oldList;
             lock (_taintLock)
@@ -924,7 +1101,7 @@ public sealed class BSScene : PhysicsScene, IPhysicsParameters
         string xval = val;
         List<uint> xlIDs = lIDs;
         string xparm = parm;
-        TaintedObject("BSScene.UpdateParameterSet", delegate() {
+        TaintedObject(DetailLogZero, "BSScene.UpdateParameterSet", delegate() {
             BSParam.ParameterDefnBase thisParam;
             if (BSParam.TryGetParameter(xparm, out thisParam))
             {
@@ -963,8 +1140,6 @@ public sealed class BSScene : PhysicsScene, IPhysicsParameters
     public void DetailLog(string msg, params Object[] args)
     {
         PhysicsLogging.Write(msg, args);
-        // Add the Flush() if debugging crashes. Gets all the messages written out.
-        if (m_physicsLoggingDoFlush) PhysicsLogging.Flush();
     }
     // Used to fill in the LocalID when there isn't one. It's the correct number of characters.
     public const string DetailLogZero = "0000000000";
diff --git a/OpenSim/Region/Physics/BulletSPlugin/BSShapeCollection.cs b/OpenSim/Region/Physics/BulletSPlugin/BSShapeCollection.cs
index 220fbbc..32bbc8f 100755
--- a/OpenSim/Region/Physics/BulletSPlugin/BSShapeCollection.cs
+++ b/OpenSim/Region/Physics/BulletSPlugin/BSShapeCollection.cs
@@ -38,38 +38,15 @@ public sealed class BSShapeCollection : IDisposable
 {
     private static string LogHeader = "[BULLETSIM SHAPE COLLECTION]";
 
-    private BSScene PhysicsScene { get; set; }
+    private BSScene m_physicsScene { get; set; }
 
     private Object m_collectionActivityLock = new Object();
 
-    // Description of a Mesh
-    private struct MeshDesc
-    {
-        public BulletShape shape;
-        public int referenceCount;
-        public DateTime lastReferenced;
-        public UInt64 shapeKey;
-    }
-
-    // Description of a hull.
-    // Meshes and hulls have the same shape hash key but we only need hulls for efficient collision calculations.
-    private struct HullDesc
-    {
-        public BulletShape shape;
-        public int referenceCount;
-        public DateTime lastReferenced;
-        public UInt64 shapeKey;
-    }
-
-    // The sharable set of meshes and hulls. Indexed by their shape hash.
-    private Dictionary<System.UInt64, MeshDesc> Meshes = new Dictionary<System.UInt64, MeshDesc>();
-    private Dictionary<System.UInt64, HullDesc> Hulls = new Dictionary<System.UInt64, HullDesc>();
-
     private bool DDetail = false;
 
     public BSShapeCollection(BSScene physScene)
     {
-        PhysicsScene = physScene;
+        m_physicsScene = physScene;
         // Set the next to 'true' for very detailed shape update detailed logging (detailed details?)
         // While detailed debugging is still active, this is better than commenting out all the
         //     DetailLog statements. When debugging slows down, this and the protected logging
@@ -86,22 +63,18 @@ public sealed class BSShapeCollection : IDisposable
     // Mostly used for changing bodies out from under Linksets.
     // Useful for other cases where parameters need saving.
     // Passing 'null' says no callback.
-    public delegate void ShapeDestructionCallback(BulletShape shape);
-    public delegate void BodyDestructionCallback(BulletBody body);
+    public delegate void PhysicalDestructionCallback(BulletBody pBody, BulletShape pShape);
 
     // Called to update/change the body and shape for an object.
-    // First checks the shape and updates that if necessary then makes
-    //    sure the body is of the right type.
+    // The object has some shape and body on it. Here we decide if that is the correct shape
+    //    for the current state of the object (static/dynamic/...).
+    // If bodyCallback is not null, it is called if either the body or the shape are changed
+    //    so dependencies (like constraints) can be removed before the physical object is dereferenced.
     // Return 'true' if either the body or the shape changed.
-    // 'shapeCallback' and 'bodyCallback' are, if non-null, functions called just before
-    //    the current shape or body is destroyed. This allows the caller to remove any
-    //    higher level dependencies on the shape or body. Mostly used for LinkSets to
-    //    remove the physical constraints before the body is destroyed.
-    // Called at taint-time!!
-    public bool GetBodyAndShape(bool forceRebuild, BulletWorld sim, BSPhysObject prim,
-                    ShapeDestructionCallback shapeCallback, BodyDestructionCallback bodyCallback)
+    // Called at taint-time.
+    public bool GetBodyAndShape(bool forceRebuild, BulletWorld sim, BSPhysObject prim, PhysicalDestructionCallback bodyCallback)
     {
-        PhysicsScene.AssertInTaintTime("BSShapeCollection.GetBodyAndShape");
+        m_physicsScene.AssertInTaintTime("BSShapeCollection.GetBodyAndShape");
 
         bool ret = false;
 
@@ -111,12 +84,12 @@ public sealed class BSShapeCollection : IDisposable
             // Do we have the correct geometry for this type of object?
             // Updates prim.BSShape with information/pointers to shape.
             // Returns 'true' of BSShape is changed to a new shape.
-            bool newGeom = CreateGeom(forceRebuild, prim, shapeCallback);
+            bool newGeom = CreateGeom(forceRebuild, prim, bodyCallback);
             // If we had to select a new shape geometry for the object,
             //    rebuild the body around it.
             // Updates prim.BSBody with information/pointers to requested body
             // Returns 'true' if BSBody was changed.
-            bool newBody = CreateBody((newGeom || forceRebuild), prim, PhysicsScene.World, bodyCallback);
+            bool newBody = CreateBody((newGeom || forceRebuild), prim, m_physicsScene.World, bodyCallback);
             ret = newGeom || newBody;
         }
         DetailLog("{0},BSShapeCollection.GetBodyAndShape,taintExit,force={1},ret={2},body={3},shape={4}",
@@ -127,274 +100,20 @@ public sealed class BSShapeCollection : IDisposable
 
     public bool GetBodyAndShape(bool forceRebuild, BulletWorld sim, BSPhysObject prim)
     {
-        return GetBodyAndShape(forceRebuild, sim, prim, null, null);
-    }
-
-    // Track another user of a body.
-    // We presume the caller has allocated the body.
-    // Bodies only have one user so the body is just put into the world if not already there.
-    private void ReferenceBody(BulletBody body)
-    {
-        lock (m_collectionActivityLock)
-        {
-            if (DDetail) DetailLog("{0},BSShapeCollection.ReferenceBody,newBody,body={1}", body.ID, body);
-            if (!PhysicsScene.PE.IsInWorld(PhysicsScene.World, body))
-            {
-                PhysicsScene.PE.AddObjectToWorld(PhysicsScene.World, body);
-                if (DDetail) DetailLog("{0},BSShapeCollection.ReferenceBody,addedToWorld,ref={1}", body.ID, body);
-            }
-        }
-    }
-
-    // Release the usage of a body.
-    // Called when releasing use of a BSBody. BSShape is handled separately.
-    // Called in taint time.
-    public void DereferenceBody(BulletBody body, BodyDestructionCallback bodyCallback )
-    {
-        if (!body.HasPhysicalBody)
-            return;
-
-        PhysicsScene.AssertInTaintTime("BSShapeCollection.DereferenceBody");
-
-        lock (m_collectionActivityLock)
-        {
-            if (DDetail) DetailLog("{0},BSShapeCollection.DereferenceBody,DestroyingBody,body={1}", body.ID, body);
-            // If the caller needs to know the old body is going away, pass the event up.
-            if (bodyCallback != null) bodyCallback(body);
-
-            if (PhysicsScene.PE.IsInWorld(PhysicsScene.World, body))
-            {
-                PhysicsScene.PE.RemoveObjectFromWorld(PhysicsScene.World, body);
-                if (DDetail) DetailLog("{0},BSShapeCollection.DereferenceBody,removingFromWorld. Body={1}", body.ID, body);
-            }
-
-            // Zero any reference to the shape so it is not freed when the body is deleted.
-            PhysicsScene.PE.SetCollisionShape(PhysicsScene.World, body, null);
-            PhysicsScene.PE.DestroyObject(PhysicsScene.World, body);
-        }
-    }
-
-    // Track the datastructures and use count for a shape.
-    // When creating a hull, this is called first to reference the mesh
-    //     and then again to reference the hull.
-    // Meshes and hulls for the same shape have the same hash key.
-    // NOTE that native shapes are not added to the mesh list or removed.
-    // Returns 'true' if this is the initial reference to the shape. Otherwise reused.
-    public bool ReferenceShape(BulletShape shape)
-    {
-        bool ret = false;
-        switch (shape.type)
-        {
-            case BSPhysicsShapeType.SHAPE_MESH:
-                MeshDesc meshDesc;
-                if (Meshes.TryGetValue(shape.shapeKey, out meshDesc))
-                {
-                    // There is an existing instance of this mesh.
-                    meshDesc.referenceCount++;
-                    if (DDetail) DetailLog("{0},BSShapeCollection.ReferenceShape,existingMesh,key={1},cnt={2}",
-                                BSScene.DetailLogZero, shape.shapeKey.ToString("X"), meshDesc.referenceCount);
-                }
-                else
-                {
-                    // This is a new reference to a mesh
-                    meshDesc.shape = shape.Clone();
-                    meshDesc.shapeKey = shape.shapeKey;
-                    // We keep a reference to the underlying IMesh data so a hull can be built
-                    meshDesc.referenceCount = 1;
-                    if (DDetail) DetailLog("{0},BSShapeCollection.ReferenceShape,newMesh,key={1},cnt={2}",
-                                BSScene.DetailLogZero, shape.shapeKey.ToString("X"), meshDesc.referenceCount);
-                    ret = true;
-                }
-                meshDesc.lastReferenced = System.DateTime.Now;
-                Meshes[shape.shapeKey] = meshDesc;
-                break;
-            case BSPhysicsShapeType.SHAPE_HULL:
-                HullDesc hullDesc;
-                if (Hulls.TryGetValue(shape.shapeKey, out hullDesc))
-                {
-                    // There is an existing instance of this hull.
-                    hullDesc.referenceCount++;
-                    if (DDetail) DetailLog("{0},BSShapeCollection.ReferenceShape,existingHull,key={1},cnt={2}",
-                                BSScene.DetailLogZero, shape.shapeKey.ToString("X"), hullDesc.referenceCount);
-                }
-                else
-                {
-                    // This is a new reference to a hull
-                    hullDesc.shape = shape.Clone();
-                    hullDesc.shapeKey = shape.shapeKey;
-                    hullDesc.referenceCount = 1;
-                    if (DDetail) DetailLog("{0},BSShapeCollection.ReferenceShape,newHull,key={1},cnt={2}",
-                                BSScene.DetailLogZero, shape.shapeKey.ToString("X"), hullDesc.referenceCount);
-                    ret = true;
-
-                }
-                hullDesc.lastReferenced = System.DateTime.Now;
-                Hulls[shape.shapeKey] = hullDesc;
-                break;
-            case BSPhysicsShapeType.SHAPE_UNKNOWN:
-                break;
-            default:
-                // Native shapes are not tracked and they don't go into any list
-                break;
-        }
-        return ret;
+        return GetBodyAndShape(forceRebuild, sim, prim, null);
     }
 
-    // Release the usage of a shape.
-    public void DereferenceShape(BulletShape shape, ShapeDestructionCallback shapeCallback)
+    // If the existing prim's shape is to be replaced, remove the tie to the existing shape
+    //     before replacing it.
+    private void DereferenceExistingShape(BSPhysObject prim, PhysicalDestructionCallback shapeCallback)
     {
-        if (!shape.HasPhysicalShape)
-            return;
-
-        PhysicsScene.AssertInTaintTime("BSShapeCollection.DereferenceShape");
-
-        if (shape.HasPhysicalShape)
-        {
-            if (shape.isNativeShape)
-            {
-                // Native shapes are not tracked and are released immediately
-                if (DDetail) DetailLog("{0},BSShapeCollection.DereferenceShape,deleteNativeShape,ptr={1}",
-                                    BSScene.DetailLogZero, shape.AddrString);
-                if (shapeCallback != null) shapeCallback(shape);
-                PhysicsScene.PE.DeleteCollisionShape(PhysicsScene.World, shape);
-            }
-            else
-            {
-                switch (shape.type)
-                {
-                    case BSPhysicsShapeType.SHAPE_HULL:
-                        DereferenceHull(shape, shapeCallback);
-                        break;
-                    case BSPhysicsShapeType.SHAPE_MESH:
-                        DereferenceMesh(shape, shapeCallback);
-                        break;
-                    case BSPhysicsShapeType.SHAPE_COMPOUND:
-                        DereferenceCompound(shape, shapeCallback);
-                        break;
-                    case BSPhysicsShapeType.SHAPE_UNKNOWN:
-                        break;
-                    default:
-                        break;
-                }
-            }
-        }
-    }
-
-    // Count down the reference count for a mesh shape
-    // Called at taint-time.
-    private void DereferenceMesh(BulletShape shape, ShapeDestructionCallback shapeCallback)
-    {
-        MeshDesc meshDesc;
-        if (Meshes.TryGetValue(shape.shapeKey, out meshDesc))
+        if (prim.PhysShape.HasPhysicalShape)
         {
-            meshDesc.referenceCount--;
-            // TODO: release the Bullet storage
-            if (shapeCallback != null) shapeCallback(shape);
-            meshDesc.lastReferenced = System.DateTime.Now;
-            Meshes[shape.shapeKey] = meshDesc;
-            if (DDetail) DetailLog("{0},BSShapeCollection.DereferenceMesh,shape={1},refCnt={2}",
-                                BSScene.DetailLogZero, shape, meshDesc.referenceCount);
-
-        }
-    }
-
-    // Count down the reference count for a hull shape
-    // Called at taint-time.
-    private void DereferenceHull(BulletShape shape, ShapeDestructionCallback shapeCallback)
-    {
-        HullDesc hullDesc;
-        if (Hulls.TryGetValue(shape.shapeKey, out hullDesc))
-        {
-            hullDesc.referenceCount--;
-            // TODO: release the Bullet storage (aging old entries?)
-
-            // Tell upper layers that, if they have dependencies on this shape, this link is going away
-            if (shapeCallback != null) shapeCallback(shape);
-
-            hullDesc.lastReferenced = System.DateTime.Now;
-            Hulls[shape.shapeKey] = hullDesc;
-            if (DDetail) DetailLog("{0},BSShapeCollection.DereferenceHull,shape={1},refCnt={2}",
-                    BSScene.DetailLogZero, shape, hullDesc.referenceCount);
-        }
-    }
-
-    // Remove a reference to a compound shape.
-    // Taking a compound shape apart is a little tricky because if you just delete the
-    //      physical shape, it will free all the underlying children. We can't do that because
-    //      they could be shared. So, this removes each of the children from the compound and
-    //      dereferences them separately before destroying the compound collision object itself.
-    // Called at taint-time.
-    private void DereferenceCompound(BulletShape shape, ShapeDestructionCallback shapeCallback)
-    {
-        if (!PhysicsScene.PE.IsCompound(shape))
-        {
-            // Failed the sanity check!!
-            PhysicsScene.Logger.ErrorFormat("{0} Attempt to free a compound shape that is not compound!! type={1}, ptr={2}",
-                                        LogHeader, shape.type, shape.AddrString);
-            if (DDetail) DetailLog("{0},BSShapeCollection.DereferenceCompound,notACompoundShape,type={1},ptr={2}",
-                                        BSScene.DetailLogZero, shape.type, shape.AddrString);
-            return;
-        }
-
-        int numChildren = PhysicsScene.PE.GetNumberOfCompoundChildren(shape);
-        if (DDetail) DetailLog("{0},BSShapeCollection.DereferenceCompound,shape={1},children={2}", BSScene.DetailLogZero, shape, numChildren);
-
-        for (int ii = numChildren - 1; ii >= 0; ii--)
-        {
-            BulletShape childShape = PhysicsScene.PE.RemoveChildShapeFromCompoundShapeIndex(shape, ii);
-            DereferenceAnonCollisionShape(childShape);
-        }
-        PhysicsScene.PE.DeleteCollisionShape(PhysicsScene.World, shape);
-    }
-
-    // Sometimes we have a pointer to a collision shape but don't know what type it is.
-    // Figure out type and call the correct dereference routine.
-    // Called at taint-time.
-    private void DereferenceAnonCollisionShape(BulletShape shapeInfo)
-    {
-        MeshDesc meshDesc;
-        HullDesc hullDesc;
-
-        if (TryGetMeshByPtr(shapeInfo, out meshDesc))
-        {
-            shapeInfo.type = BSPhysicsShapeType.SHAPE_MESH;
-            shapeInfo.shapeKey = meshDesc.shapeKey;
-        }
-        else
-        {
-            if (TryGetHullByPtr(shapeInfo, out hullDesc))
-            {
-                shapeInfo.type = BSPhysicsShapeType.SHAPE_HULL;
-                shapeInfo.shapeKey = hullDesc.shapeKey;
-            }
-            else
-            {
-                if (PhysicsScene.PE.IsCompound(shapeInfo))
-                {
-                    shapeInfo.type = BSPhysicsShapeType.SHAPE_COMPOUND;
-                }
-                else
-                {
-                    if (PhysicsScene.PE.IsNativeShape(shapeInfo))
-                    {
-                        shapeInfo.isNativeShape = true;
-                        shapeInfo.type = BSPhysicsShapeType.SHAPE_BOX; // (technically, type doesn't matter)
-                    }
-                }
-            }
-        }
-
-        if (DDetail) DetailLog("{0},BSShapeCollection.DereferenceAnonCollisionShape,shape={1}", BSScene.DetailLogZero, shapeInfo);
-
-        if (shapeInfo.type != BSPhysicsShapeType.SHAPE_UNKNOWN)
-        {
-            DereferenceShape(shapeInfo, null);
-        }
-        else
-        {
-            PhysicsScene.Logger.ErrorFormat("{0} Could not decypher shape type. Region={1}, addr={2}",
-                                    LogHeader, PhysicsScene.RegionName, shapeInfo.AddrString);
+            if (shapeCallback != null)
+                shapeCallback(prim.PhysBody, prim.PhysShape.physShapeInfo);
+            prim.PhysShape.Dereference(m_physicsScene);
         }
+        prim.PhysShape = new BSShapeNull();
     }
 
     // Create the geometry information in Bullet for later use.
@@ -405,60 +124,41 @@ public sealed class BSShapeCollection : IDisposable
     // Info in prim.BSShape is updated to the new shape.
     // Returns 'true' if the geometry was rebuilt.
     // Called at taint-time!
-    private bool CreateGeom(bool forceRebuild, BSPhysObject prim, ShapeDestructionCallback shapeCallback)
+    private bool CreateGeom(bool forceRebuild, BSPhysObject prim, PhysicalDestructionCallback shapeCallback)
     {
         bool ret = false;
         bool haveShape = false;
+        bool nativeShapePossible = true;
+        PrimitiveBaseShape pbs = prim.BaseShape;
 
-        if (!haveShape && prim.PreferredPhysicalShape == BSPhysicsShapeType.SHAPE_CAPSULE)
+        // Kludge to create the capsule for the avatar.
+        // TDOD: Remove/redo this when BSShapeAvatar is working!!
+        BSCharacter theChar = prim as BSCharacter;
+        if (theChar != null)
         {
-            // an avatar capsule is close to a native shape (it is not shared)
-            GetReferenceToNativeShape(prim, BSPhysicsShapeType.SHAPE_CAPSULE, FixedShapeKey.KEY_CAPSULE, shapeCallback);
-            if (DDetail) DetailLog("{0},BSShapeCollection.CreateGeom,avatarCapsule,shape={1}", prim.LocalID, prim.PhysShape);
+            DereferenceExistingShape(prim, shapeCallback);
+            prim.PhysShape = BSShapeNative.GetReference(m_physicsScene, prim,
+                                            BSPhysicsShapeType.SHAPE_CAPSULE, FixedShapeKey.KEY_CAPSULE);
             ret = true;
             haveShape = true;
         }
 
-        // Compound shapes are handled special as they are rebuilt from scratch.
-        // This isn't too great a hardship since most of the child shapes will have already been created.
-        if (!haveShape && prim.PreferredPhysicalShape == BSPhysicsShapeType.SHAPE_COMPOUND)
-        {
-            ret = GetReferenceToCompoundShape(prim, shapeCallback);
-            if (DDetail) DetailLog("{0},BSShapeCollection.CreateGeom,compoundShape,shape={1}", prim.LocalID, prim.PhysShape);
-            haveShape = true;
-        }
-
-        if (!haveShape)
-        {
-            ret = CreateGeomNonSpecial(forceRebuild, prim, shapeCallback);
-        }
-
-        return ret;
-    }
-
-    // Create a mesh, hull or native shape.
-    // Return 'true' if the prim's shape was changed.
-    public bool CreateGeomNonSpecial(bool forceRebuild, BSPhysObject prim, ShapeDestructionCallback shapeCallback)
-    {
-        bool ret = false;
-        bool haveShape = false;
-        bool nativeShapePossible = true;
-        PrimitiveBaseShape pbs = prim.BaseShape;
-
         // If the prim attributes are simple, this could be a simple Bullet native shape
+        // Native shapes work whether to object is static or physical.
         if (!haveShape
                 && nativeShapePossible
                 && pbs != null
-                && !pbs.SculptEntry
-                && ((pbs.SculptEntry && !BSParam.ShouldMeshSculptedPrim) || PrimHasNoCuts(pbs)) )
+                && PrimHasNoCuts(pbs)
+                && ( !pbs.SculptEntry || (pbs.SculptEntry && !BSParam.ShouldMeshSculptedPrim) )
+            )
         {
             // Get the scale of any existing shape so we can see if the new shape is same native type and same size.
             OMV.Vector3 scaleOfExistingShape = OMV.Vector3.Zero;
             if (prim.PhysShape.HasPhysicalShape)
-                scaleOfExistingShape = PhysicsScene.PE.GetLocalScaling(prim.PhysShape);
+                scaleOfExistingShape = m_physicsScene.PE.GetLocalScaling(prim.PhysShape.physShapeInfo);
 
             if (DDetail) DetailLog("{0},BSShapeCollection.CreateGeom,maybeNative,force={1},primScale={2},primSize={3},primShape={4}",
-                        prim.LocalID, forceRebuild, prim.Scale, prim.Size, prim.PhysShape.type);
+                        prim.LocalID, forceRebuild, prim.Scale, prim.Size, prim.PhysShape.physShapeInfo.shapeType);
 
             // It doesn't look like Bullet scales native spheres so make sure the scales are all equal
             if ((pbs.ProfileShape == ProfileShape.HalfCircle && pbs.PathCurve == (byte)Extrusion.Curve1)
@@ -466,26 +166,30 @@ public sealed class BSShapeCollection : IDisposable
             {
                 haveShape = true;
                 if (forceRebuild
-                        || prim.Scale != scaleOfExistingShape
-                        || prim.PhysShape.type != BSPhysicsShapeType.SHAPE_SPHERE
-                        )
+                        || prim.PhysShape.ShapeType != BSPhysicsShapeType.SHAPE_SPHERE
+                    )
                 {
-                    ret = GetReferenceToNativeShape(prim, BSPhysicsShapeType.SHAPE_SPHERE,
-                                            FixedShapeKey.KEY_SPHERE, shapeCallback);
+                    DereferenceExistingShape(prim, shapeCallback);
+                    prim.PhysShape = BSShapeNative.GetReference(m_physicsScene, prim,
+                                            BSPhysicsShapeType.SHAPE_SPHERE, FixedShapeKey.KEY_SPHERE);
+                    ret = true;
                 }
                 if (DDetail) DetailLog("{0},BSShapeCollection.CreateGeom,sphere,force={1},rebuilt={2},shape={3}",
                                         prim.LocalID, forceRebuild, ret, prim.PhysShape);
             }
+            // If we didn't make a sphere, maybe a box will work.
             if (!haveShape && pbs.ProfileShape == ProfileShape.Square && pbs.PathCurve == (byte)Extrusion.Straight)
             {
                 haveShape = true;
                 if (forceRebuild
                         || prim.Scale != scaleOfExistingShape
-                        || prim.PhysShape.type != BSPhysicsShapeType.SHAPE_BOX
+                        || prim.PhysShape.ShapeType != BSPhysicsShapeType.SHAPE_BOX
                         )
                 {
-                    ret = GetReferenceToNativeShape( prim, BSPhysicsShapeType.SHAPE_BOX,
-                                            FixedShapeKey.KEY_BOX, shapeCallback);
+                    DereferenceExistingShape(prim, shapeCallback);
+                    prim.PhysShape = BSShapeNative.GetReference(m_physicsScene, prim,
+                                            BSPhysicsShapeType.SHAPE_BOX, FixedShapeKey.KEY_BOX);
+                    ret = true;
                 }
                 if (DDetail) DetailLog("{0},BSShapeCollection.CreateGeom,box,force={1},rebuilt={2},shape={3}",
                                         prim.LocalID, forceRebuild, ret, prim.PhysShape);
@@ -502,7 +206,7 @@ public sealed class BSShapeCollection : IDisposable
     }
 
     // return 'true' if this shape description does not include any cutting or twisting.
-    private bool PrimHasNoCuts(PrimitiveBaseShape pbs)
+    public static bool PrimHasNoCuts(PrimitiveBaseShape pbs)
     {
         return pbs.ProfileBegin == 0 && pbs.ProfileEnd == 0
             && pbs.ProfileHollow == 0
@@ -514,7 +218,7 @@ public sealed class BSShapeCollection : IDisposable
     }
 
     // return 'true' if the prim's shape was changed.
-    public bool CreateGeomMeshOrHull(BSPhysObject prim, ShapeDestructionCallback shapeCallback)
+    private bool CreateGeomMeshOrHull(BSPhysObject prim, PhysicalDestructionCallback shapeCallback)
     {
 
         bool ret = false;
@@ -522,503 +226,121 @@ public sealed class BSShapeCollection : IDisposable
         //     made. Native shapes work in either case.
         if (prim.IsPhysical && BSParam.ShouldUseHullsForPhysicalObjects)
         {
-            // Update prim.BSShape to reference a hull of this shape.
-            ret = GetReferenceToHull(prim, shapeCallback);
-            if (DDetail) DetailLog("{0},BSShapeCollection.CreateGeom,hull,shape={1},key={2}",
-                                    prim.LocalID, prim.PhysShape, prim.PhysShape.shapeKey.ToString("X"));
-        }
-        else
-        {
-            ret = GetReferenceToMesh(prim, shapeCallback);
-            if (DDetail) DetailLog("{0},BSShapeCollection.CreateGeom,mesh,shape={1},key={2}",
-                                    prim.LocalID, prim.PhysShape, prim.PhysShape.shapeKey.ToString("X"));
-        }
-        return ret;
-    }
-
-    // Creates a native shape and assignes it to prim.BSShape.
-    // "Native" shapes are never shared. they are created here and destroyed in DereferenceShape().
-    private bool GetReferenceToNativeShape(BSPhysObject prim,
-                            BSPhysicsShapeType shapeType, FixedShapeKey shapeKey,
-                            ShapeDestructionCallback shapeCallback)
-    {
-        // release any previous shape
-        DereferenceShape(prim.PhysShape, shapeCallback);
-
-        BulletShape newShape = BuildPhysicalNativeShape(prim, shapeType, shapeKey);
-
-        // Don't need to do a 'ReferenceShape()' here because native shapes are not shared.
-        if (DDetail) DetailLog("{0},BSShapeCollection.AddNativeShapeToPrim,create,newshape={1},scale={2}",
-                                prim.LocalID, newShape, prim.Scale);
-
-        // native shapes are scaled by Bullet
-        prim.PhysShape = newShape;
-        return true;
-    }
-
-    private BulletShape BuildPhysicalNativeShape(BSPhysObject prim, BSPhysicsShapeType shapeType,
-                                    FixedShapeKey shapeKey)
-    {
-        BulletShape newShape;
-        // Need to make sure the passed shape information is for the native type.
-        ShapeData nativeShapeData = new ShapeData();
-        nativeShapeData.Type = shapeType;
-        nativeShapeData.ID = prim.LocalID;
-        nativeShapeData.Scale = prim.Scale;
-        nativeShapeData.Size = prim.Scale;  // unneeded, I think.
-        nativeShapeData.MeshKey = (ulong)shapeKey;
-        nativeShapeData.HullKey = (ulong)shapeKey;
-
-        if (shapeType == BSPhysicsShapeType.SHAPE_CAPSULE)
-        {
+            // Use a simple, single mesh convex hull shape if the object is simple enough
+            BSShape potentialHull = null;
 
-            newShape = PhysicsScene.PE.BuildCapsuleShape(PhysicsScene.World, 1f, 1f, prim.Scale);
-            if (DDetail) DetailLog("{0},BSShapeCollection.BuildPhysicalNativeShape,capsule,scale={1}", prim.LocalID, prim.Scale);
-        }
-        else
-        {
-            // Native shapes are scaled in Bullet so set the scaling to the size
-            newShape = PhysicsScene.PE.BuildNativeShape(PhysicsScene.World, nativeShapeData);
-
-        }
-        if (!newShape.HasPhysicalShape)
-        {
-            PhysicsScene.Logger.ErrorFormat("{0} BuildPhysicalNativeShape failed. ID={1}, shape={2}",
-                                    LogHeader, prim.LocalID, shapeType);
-        }
-        newShape.shapeKey = (System.UInt64)shapeKey;
-        newShape.isNativeShape = true;
-
-        return newShape;
-    }
-
-    // Builds a mesh shape in the physical world and updates prim.BSShape.
-    // Dereferences previous shape in BSShape and adds a reference for this new shape.
-    // Returns 'true' of a mesh was actually built. Otherwise .
-    // Called at taint-time!
-    private bool GetReferenceToMesh(BSPhysObject prim, ShapeDestructionCallback shapeCallback)
-    {
-        BulletShape newShape = new BulletShape();
-
-        float lod;
-        System.UInt64 newMeshKey = ComputeShapeKey(prim.Size, prim.BaseShape, out lod);
-
-        // if this new shape is the same as last time, don't recreate the mesh
-        if (newMeshKey == prim.PhysShape.shapeKey && prim.PhysShape.type == BSPhysicsShapeType.SHAPE_MESH)
-            return false;
-
-        if (DDetail) DetailLog("{0},BSShapeCollection.GetReferenceToMesh,create,oldKey={1},newKey={2},size={3},lod={4}",
-                                prim.LocalID, prim.PhysShape.shapeKey.ToString("X"), newMeshKey.ToString("X"), prim.Size, lod);
-
-        // Since we're recreating new, get rid of the reference to the previous shape
-        DereferenceShape(prim.PhysShape, shapeCallback);
-
-        newShape = CreatePhysicalMesh(prim, newMeshKey, prim.BaseShape, prim.Size, lod);
-        // Take evasive action if the mesh was not constructed.
-        newShape = VerifyMeshCreated(newShape, prim);
-
-        ReferenceShape(newShape);
-
-        prim.PhysShape = newShape;
-
-        return true;        // 'true' means a new shape has been added to this prim
-    }
-
-    private BulletShape CreatePhysicalMesh(BSPhysObject prim, System.UInt64 newMeshKey, PrimitiveBaseShape pbs, OMV.Vector3 size, float lod)
-    {
-        BulletShape newShape = new BulletShape();
+            PrimitiveBaseShape pbs = prim.BaseShape;
+            // Use a simple, one section convex shape for prims that are probably convex (no cuts or twists)
+            if (BSParam.ShouldUseSingleConvexHullForPrims
+                && pbs != null
+                && !pbs.SculptEntry
+                && PrimHasNoCuts(pbs)
+                )
+            {
+                potentialHull = BSShapeConvexHull.GetReference(m_physicsScene, false /* forceRebuild */, prim);
+            }
+            // Use the GImpact shape if it is a prim that has some concaveness
+            if (potentialHull == null
+                && BSParam.ShouldUseGImpactShapeForPrims
+                && pbs != null
+                && !pbs.SculptEntry
+                )
+            {
+                    potentialHull = BSShapeGImpact.GetReference(m_physicsScene, false /* forceRebuild */, prim);
+            }
+            // If not any of the simple cases, just make a hull
+            if (potentialHull == null)
+            {
+                potentialHull = BSShapeHull.GetReference(m_physicsScene, false /*forceRebuild*/, prim);
+            }
 
-        MeshDesc meshDesc;
-        if (Meshes.TryGetValue(newMeshKey, out meshDesc))
-        {
-            // If the mesh has already been built just use it.
-            newShape = meshDesc.shape.Clone();
+            // If the current shape is not what is on the prim at the moment, time to change.
+            if (!prim.PhysShape.HasPhysicalShape
+                        || potentialHull.ShapeType != prim.PhysShape.ShapeType
+                        || potentialHull.physShapeInfo.shapeKey != prim.PhysShape.physShapeInfo.shapeKey)
+            {
+                DereferenceExistingShape(prim, shapeCallback);
+                prim.PhysShape = potentialHull;
+                ret = true;
+            }
+            else
+            {
+                // The current shape on the prim is the correct one. We don't need the potential reference.
+                potentialHull.Dereference(m_physicsScene);
+            }
+            if (DDetail) DetailLog("{0},BSShapeCollection.CreateGeom,hull,shape={1}", prim.LocalID, prim.PhysShape);
         }
         else
         {
-            IMesh meshData = PhysicsScene.mesher.CreateMesh(prim.PhysObjectName, pbs, size, lod, 
-                                        true,
-                                        false,  // say it is not physical so a bounding box is not built
-                                        false,  // do not cache the mesh and do not use previously built versions
-                                        false   // It's NOT for ODE
-                                        );
-
-            if (meshData != null)
+            // Non-physical objects should be just meshes.
+            BSShape potentialMesh = BSShapeMesh.GetReference(m_physicsScene, false /*forceRebuild*/, prim);
+            // If the current shape is not what is on the prim at the moment, time to change.
+            if (!prim.PhysShape.HasPhysicalShape
+                        || potentialMesh.ShapeType != prim.PhysShape.ShapeType
+                        || potentialMesh.physShapeInfo.shapeKey != prim.PhysShape.physShapeInfo.shapeKey)
             {
-
-                int[] indices = meshData.getIndexListAsInt();
-                int realIndicesIndex = indices.Length;
-                float[] verticesAsFloats = meshData.getVertexListAsFloat();
-
-                if (BSParam.ShouldRemoveZeroWidthTriangles)
-                {
-                    // Remove degenerate triangles. These are triangles with two of the vertices
-                    //    are the same. This is complicated by the problem that vertices are not
-                    //    made unique in sculpties so we have to compare the values in the vertex.
-                    realIndicesIndex = 0;
-                    for (int tri = 0; tri < indices.Length; tri += 3)
-                    {
-                        // Compute displacements into vertex array for each vertex of the triangle
-                        int v1 = indices[tri + 0] * 3;
-                        int v2 = indices[tri + 1] * 3;
-                        int v3 = indices[tri + 2] * 3;
-                        // Check to see if any two of the vertices are the same
-                        if (!( (  verticesAsFloats[v1 + 0] == verticesAsFloats[v2 + 0]
-                               && verticesAsFloats[v1 + 1] == verticesAsFloats[v2 + 1]
-                               && verticesAsFloats[v1 + 2] == verticesAsFloats[v2 + 2])
-                            || (  verticesAsFloats[v2 + 0] == verticesAsFloats[v3 + 0]
-                               && verticesAsFloats[v2 + 1] == verticesAsFloats[v3 + 1]
-                               && verticesAsFloats[v2 + 2] == verticesAsFloats[v3 + 2])
-                            || (  verticesAsFloats[v1 + 0] == verticesAsFloats[v3 + 0]
-                               && verticesAsFloats[v1 + 1] == verticesAsFloats[v3 + 1]
-                               && verticesAsFloats[v1 + 2] == verticesAsFloats[v3 + 2]) )
-                        )
-                        {
-                            // None of the vertices of the triangles are the same. This is a good triangle;
-                            indices[realIndicesIndex + 0] = indices[tri + 0];
-                            indices[realIndicesIndex + 1] = indices[tri + 1];
-                            indices[realIndicesIndex + 2] = indices[tri + 2];
-                            realIndicesIndex += 3;
-                        }
-                    }
-                }
-                DetailLog("{0},BSShapeCollection.CreatePhysicalMesh,origTri={1},realTri={2},numVerts={3}",
-                            BSScene.DetailLogZero, indices.Length / 3, realIndicesIndex / 3, verticesAsFloats.Length / 3);
-
-                if (realIndicesIndex != 0)
-                {
-                    newShape = PhysicsScene.PE.CreateMeshShape(PhysicsScene.World,
-                                        realIndicesIndex, indices, verticesAsFloats.Length / 3, verticesAsFloats);
-                }
-                else
-                {
-                    PhysicsScene.Logger.DebugFormat("{0} All mesh triangles degenerate. Prim {1} at {2} in {3}",
-                                        LogHeader, prim.PhysObjectName, prim.RawPosition, PhysicsScene.Name);
-                }
+                DereferenceExistingShape(prim, shapeCallback);
+                prim.PhysShape = potentialMesh;
+                ret = true;
             }
+            else
+            {
+                // We don't need this reference to the mesh that is already being using.
+                potentialMesh.Dereference(m_physicsScene);
+            }
+            if (DDetail) DetailLog("{0},BSShapeCollection.CreateGeom,mesh,shape={1}", prim.LocalID, prim.PhysShape);
         }
-        newShape.shapeKey = newMeshKey;
-
-        return newShape;
-    }
-
-    // See that hull shape exists in the physical world and update prim.BSShape.
-    // We could be creating the hull because scale changed or whatever.
-    // Return 'true' if a new hull was built. Otherwise, returning a shared hull instance.
-    private bool GetReferenceToHull(BSPhysObject prim, ShapeDestructionCallback shapeCallback)
-    {
-        BulletShape newShape;
-
-        float lod;
-        System.UInt64 newHullKey = ComputeShapeKey(prim.Size, prim.BaseShape, out lod);
-
-        // if the hull hasn't changed, don't rebuild it
-        if (newHullKey == prim.PhysShape.shapeKey && prim.PhysShape.type == BSPhysicsShapeType.SHAPE_HULL)
-            return false;
-
-        if (DDetail) DetailLog("{0},BSShapeCollection.GetReferenceToHull,create,oldKey={1},newKey={2}",
-                        prim.LocalID, prim.PhysShape.shapeKey.ToString("X"), newHullKey.ToString("X"));
-
-        // Remove usage of the previous shape.
-        DereferenceShape(prim.PhysShape, shapeCallback);
-
-        newShape = CreatePhysicalHull(prim.PhysObjectName, newHullKey, prim.BaseShape, prim.Size, lod);
-        // It might not have been created if we're waiting for an asset.
-        newShape = VerifyMeshCreated(newShape, prim);
-
-        ReferenceShape(newShape);
-
-        prim.PhysShape = newShape;
-        return true;        // 'true' means a new shape has been added to this prim
+        return ret;
     }
 
-    List<ConvexResult> m_hulls;
-    private BulletShape CreatePhysicalHull(string objName, System.UInt64 newHullKey, PrimitiveBaseShape pbs, OMV.Vector3 size, float lod)
+    // Track another user of a body.
+    // We presume the caller has allocated the body.
+    // Bodies only have one user so the body is just put into the world if not already there.
+    private void ReferenceBody(BulletBody body)
     {
-
-        BulletShape newShape = new BulletShape();
-        IntPtr hullPtr = IntPtr.Zero;
-
-        HullDesc hullDesc;
-        if (Hulls.TryGetValue(newHullKey, out hullDesc))
-        {
-            // If the hull shape already has been created, just use the one shared instance.
-            newShape = hullDesc.shape.Clone();
-        }
-        else
+        lock (m_collectionActivityLock)
         {
-            // Build a new hull in the physical world.
-            // Pass true for physicalness as this prevents the creation of bounding box which is not needed
-            IMesh meshData = PhysicsScene.mesher.CreateMesh(objName, pbs, size, lod, true, false, false, false);
-            if (meshData != null)
+            if (DDetail) DetailLog("{0},BSShapeCollection.ReferenceBody,newBody,body={1}", body.ID, body);
+            if (!m_physicsScene.PE.IsInWorld(m_physicsScene.World, body))
             {
-
-                int[] indices = meshData.getIndexListAsInt();
-                List<OMV.Vector3> vertices = meshData.getVertexList();
-
-                //format conversion from IMesh format to DecompDesc format
-                List<int> convIndices = new List<int>();
-                List<float3> convVertices = new List<float3>();
-                for (int ii = 0; ii < indices.GetLength(0); ii++)
-                {
-                    convIndices.Add(indices[ii]);
-                }
-                foreach (OMV.Vector3 vv in vertices)
-                {
-                    convVertices.Add(new float3(vv.X, vv.Y, vv.Z));
-                }
-
-                uint maxDepthSplit = (uint)BSParam.CSHullMaxDepthSplit;
-                if (BSParam.CSHullMaxDepthSplit != BSParam.CSHullMaxDepthSplitForSimpleShapes)
-                {
-                    // Simple primitive shapes we know are convex so they are better implemented with
-                    //    fewer hulls.
-                    // Check for simple shape (prim without cuts) and reduce split parameter if so.
-                    if (PrimHasNoCuts(pbs))
-                    {
-                        maxDepthSplit = (uint)BSParam.CSHullMaxDepthSplitForSimpleShapes;
-                    }
-                }
-
-                // setup and do convex hull conversion
-                m_hulls = new List<ConvexResult>();
-                DecompDesc dcomp = new DecompDesc();
-                dcomp.mIndices = convIndices;
-                dcomp.mVertices = convVertices;
-                dcomp.mDepth = maxDepthSplit;
-                dcomp.mCpercent = BSParam.CSHullConcavityThresholdPercent;
-                dcomp.mPpercent = BSParam.CSHullVolumeConservationThresholdPercent;
-                dcomp.mMaxVertices = (uint)BSParam.CSHullMaxVertices;
-                dcomp.mSkinWidth = BSParam.CSHullMaxSkinWidth;
-                ConvexBuilder convexBuilder = new ConvexBuilder(HullReturn);
-                // create the hull into the _hulls variable
-                convexBuilder.process(dcomp);
-
-                DetailLog("{0},BSShapeCollection.CreatePhysicalHull,key={1},inVert={2},inInd={3},split={4},hulls={5}",
-                                    BSScene.DetailLogZero, newHullKey, indices.GetLength(0), vertices.Count, maxDepthSplit, m_hulls.Count);
-
-                // Convert the vertices and indices for passing to unmanaged.
-                // The hull information is passed as a large floating point array.
-                // The format is:
-                //  convHulls[0] = number of hulls
-                //  convHulls[1] = number of vertices in first hull
-                //  convHulls[2] = hull centroid X coordinate
-                //  convHulls[3] = hull centroid Y coordinate
-                //  convHulls[4] = hull centroid Z coordinate
-                //  convHulls[5] = first hull vertex X
-                //  convHulls[6] = first hull vertex Y
-                //  convHulls[7] = first hull vertex Z
-                //  convHulls[8] = second hull vertex X
-                //  ...
-                //  convHulls[n] = number of vertices in second hull
-                //  convHulls[n+1] = second hull centroid X coordinate
-                //  ...
-                //
-                // TODO: is is very inefficient. Someday change the convex hull generator to return
-                //   data structures that do not need to be converted in order to pass to Bullet.
-                //   And maybe put the values directly into pinned memory rather than marshaling.
-                int hullCount = m_hulls.Count;
-                int totalVertices = 1;          // include one for the count of the hulls
-                foreach (ConvexResult cr in m_hulls)
-                {
-                    totalVertices += 4;                         // add four for the vertex count and centroid
-                    totalVertices += cr.HullIndices.Count * 3;  // we pass just triangles
-                }
-                float[] convHulls = new float[totalVertices];
-
-                convHulls[0] = (float)hullCount;
-                int jj = 1;
-                foreach (ConvexResult cr in m_hulls)
-                {
-                    // copy vertices for index access
-                    float3[] verts = new float3[cr.HullVertices.Count];
-                    int kk = 0;
-                    foreach (float3 ff in cr.HullVertices)
-                    {
-                        verts[kk++] = ff;
-                    }
-
-                    // add to the array one hull's worth of data
-                    convHulls[jj++] = cr.HullIndices.Count;
-                    convHulls[jj++] = 0f;   // centroid x,y,z
-                    convHulls[jj++] = 0f;
-                    convHulls[jj++] = 0f;
-                    foreach (int ind in cr.HullIndices)
-                    {
-                        convHulls[jj++] = verts[ind].x;
-                        convHulls[jj++] = verts[ind].y;
-                        convHulls[jj++] = verts[ind].z;
-                    }
-                }
-                // create the hull data structure in Bullet
-                newShape = PhysicsScene.PE.CreateHullShape(PhysicsScene.World, hullCount, convHulls);
+                m_physicsScene.PE.AddObjectToWorld(m_physicsScene.World, body);
+                if (DDetail) DetailLog("{0},BSShapeCollection.ReferenceBody,addedToWorld,ref={1}", body.ID, body);
             }
         }
-
-        newShape.shapeKey = newHullKey;
-
-        return newShape;
-    }
-
-    // Callback from convex hull creater with a newly created hull.
-    // Just add it to our collection of hulls for this shape.
-    private void HullReturn(ConvexResult result)
-    {
-        m_hulls.Add(result);
-        return;
     }
 
-    // Compound shapes are always built from scratch.
-    // This shouldn't be to bad since most of the parts will be meshes that had been built previously.
-    private bool GetReferenceToCompoundShape(BSPhysObject prim, ShapeDestructionCallback shapeCallback)
-    {
-        // Remove reference to the old shape
-        // Don't need to do this as the shape is freed when the new root shape is created below.
-        // DereferenceShape(prim.PhysShape, true, shapeCallback);
-
-        BulletShape cShape = PhysicsScene.PE.CreateCompoundShape(PhysicsScene.World, false);
-
-        // Create the shape for the root prim and add it to the compound shape. Cannot be a native shape.
-        CreateGeomMeshOrHull(prim, shapeCallback);
-        PhysicsScene.PE.AddChildShapeToCompoundShape(cShape, prim.PhysShape, OMV.Vector3.Zero, OMV.Quaternion.Identity);
-        if (DDetail) DetailLog("{0},BSShapeCollection.GetReferenceToCompoundShape,addRootPrim,compShape={1},rootShape={2}",
-                                    prim.LocalID, cShape, prim.PhysShape);
-
-        prim.PhysShape = cShape;
-
-        return true;
-    }
-
-    // Create a hash of all the shape parameters to be used as a key
-    //    for this particular shape.
-    private System.UInt64 ComputeShapeKey(OMV.Vector3 size, PrimitiveBaseShape pbs, out float retLod)
-    {
-        // level of detail based on size and type of the object
-        float lod = BSParam.MeshLOD;
-
-        // prims with curvy internal cuts need higher lod
-        if (pbs.HollowShape == HollowShape.Circle)
-            lod = BSParam.MeshCircularLOD;
-
-        if (pbs.SculptEntry)
-            lod = BSParam.SculptLOD;
-
-        // Mega prims usually get more detail because one can interact with shape approximations at this size.
-        float maxAxis = Math.Max(size.X, Math.Max(size.Y, size.Z));
-        if (maxAxis > BSParam.MeshMegaPrimThreshold)
-            lod = BSParam.MeshMegaPrimLOD;
-
-        retLod = lod;
-        return pbs.GetMeshKey(size, lod);
-    }
-    // For those who don't want the LOD
-    private System.UInt64 ComputeShapeKey(OMV.Vector3 size, PrimitiveBaseShape pbs)
+    // Release the usage of a body.
+    // Called when releasing use of a BSBody. BSShape is handled separately.
+    // Called in taint time.
+    public void DereferenceBody(BulletBody body, PhysicalDestructionCallback bodyCallback )
     {
-        float lod;
-        return ComputeShapeKey(size, pbs, out lod);
-    }
+        if (!body.HasPhysicalBody)
+            return;
 
-    // The creation of a mesh or hull can fail if an underlying asset is not available.
-    // There are two cases: 1) the asset is not in the cache and it needs to be fetched;
-    //     and 2) the asset cannot be converted (like failed decompression of JPEG2000s).
-    //     The first case causes the asset to be fetched. The second case requires
-    //     us to not loop forever.
-    // Called after creating a physical mesh or hull. If the physical shape was created,
-    //     just return.
-    private BulletShape VerifyMeshCreated(BulletShape newShape, BSPhysObject prim)
-    {
-        // If the shape was successfully created, nothing more to do
-        if (newShape.HasPhysicalShape)
-            return newShape;
+        m_physicsScene.AssertInTaintTime("BSShapeCollection.DereferenceBody");
 
-        // VerifyMeshCreated is called after trying to create the mesh. If we think the asset had been
-        //    fetched but we end up here again, the meshing of the asset must have failed.
-        // Prevent trying to keep fetching the mesh by declaring failure.
-        if (prim.PrimAssetState == BSPhysObject.PrimAssetCondition.Fetched)
-        {
-            prim.PrimAssetState = BSPhysObject.PrimAssetCondition.Failed;
-            PhysicsScene.Logger.WarnFormat("{0} Fetched asset would not mesh. {1}, texture={2}",
-                                            LogHeader, prim.PhysObjectName, prim.BaseShape.SculptTexture);
-        }
-        else
+        lock (m_collectionActivityLock)
         {
-            // If this mesh has an underlying asset and we have not failed getting it before, fetch the asset
-            if (prim.BaseShape.SculptEntry 
-                && prim.PrimAssetState != BSPhysObject.PrimAssetCondition.Failed
-                && prim.PrimAssetState != BSPhysObject.PrimAssetCondition.Waiting
-                && prim.BaseShape.SculptTexture != OMV.UUID.Zero
-                )
-            {
-                DetailLog("{0},BSShapeCollection.VerifyMeshCreated,fetchAsset", prim.LocalID);
-                // Multiple requestors will know we're waiting for this asset
-                prim.PrimAssetState = BSPhysObject.PrimAssetCondition.Waiting;
-
-                BSPhysObject xprim = prim;
-                Util.FireAndForget(delegate
-                    {
-                        RequestAssetDelegate assetProvider = PhysicsScene.RequestAssetMethod;
-                        if (assetProvider != null)
-                        {
-                            BSPhysObject yprim = xprim; // probably not necessary, but, just in case.
-                            assetProvider(yprim.BaseShape.SculptTexture, delegate(AssetBase asset)
-                            {
-                                bool assetFound = false;
-                                string mismatchIDs = String.Empty;  // DEBUG DEBUG
-                                if (asset != null && yprim.BaseShape.SculptEntry)
-                                {
-                                    if (yprim.BaseShape.SculptTexture.ToString() == asset.ID)
-                                    {
-                                        yprim.BaseShape.SculptData = asset.Data;
-                                        // This will cause the prim to see that the filler shape is not the right
-                                        //    one and try again to build the object.
-                                        // No race condition with the normal shape setting since the rebuild is at taint time.
-                                        yprim.ForceBodyShapeRebuild(false /* inTaintTime */);
-                                        assetFound = true;
-                                    }
-                                    else
-                                    {
-                                        mismatchIDs = yprim.BaseShape.SculptTexture.ToString() + "/" + asset.ID;
-                                    }
-                                }
-                                if (assetFound)
-                                    yprim.PrimAssetState = BSPhysObject.PrimAssetCondition.Fetched;
-                                else
-                                    yprim.PrimAssetState = BSPhysObject.PrimAssetCondition.Failed;
-                                DetailLog("{0},BSShapeCollection,fetchAssetCallback,found={1},isSculpt={2},ids={3}",
-                                            yprim.LocalID, assetFound, yprim.BaseShape.SculptEntry, mismatchIDs );
+            if (DDetail) DetailLog("{0},BSShapeCollection.DereferenceBody,DestroyingBody,body={1}", body.ID, body);
+            // If the caller needs to know the old body is going away, pass the event up.
+            if (bodyCallback != null)
+                bodyCallback(body, null);
 
-                            });
-                        }
-                        else
-                        {
-                            xprim.PrimAssetState = BSPhysObject.PrimAssetCondition.Failed;
-                            PhysicsScene.Logger.ErrorFormat("{0} Physical object requires asset but no asset provider. Name={1}",
-                                                        LogHeader, PhysicsScene.Name);
-                        }
-                    });
-            }
-            else
-            {
-                if (prim.PrimAssetState == BSPhysObject.PrimAssetCondition.Failed)
-                {
-                    PhysicsScene.Logger.WarnFormat("{0} Mesh failed to fetch asset. obj={1}, texture={2}",
-                                                LogHeader, prim.PhysObjectName, prim.BaseShape.SculptTexture);
-                }
-            }
-        }
+            // Removing an object not in the world is a NOOP
+            m_physicsScene.PE.RemoveObjectFromWorld(m_physicsScene.World, body);
 
-        // While we wait for the mesh defining asset to be loaded, stick in a simple box for the object.
-        BulletShape fillinShape = BuildPhysicalNativeShape(prim, BSPhysicsShapeType.SHAPE_BOX, FixedShapeKey.KEY_BOX);
-        DetailLog("{0},BSShapeCollection.VerifyMeshCreated,boxTempShape", prim.LocalID);
+            // Zero any reference to the shape so it is not freed when the body is deleted.
+            m_physicsScene.PE.SetCollisionShape(m_physicsScene.World, body, null);
 
-        return fillinShape;
+            m_physicsScene.PE.DestroyObject(m_physicsScene.World, body);
+        }
     }
 
     // Create a body object in Bullet.
     // Updates prim.BSBody with the information about the new body if one is created.
     // Returns 'true' if an object was actually created.
     // Called at taint-time.
-    private bool CreateBody(bool forceRebuild, BSPhysObject prim, BulletWorld sim, BodyDestructionCallback bodyCallback)
+    private bool CreateBody(bool forceRebuild, BSPhysObject prim, BulletWorld sim, PhysicalDestructionCallback bodyCallback)
     {
         bool ret = false;
 
@@ -1029,7 +351,7 @@ public sealed class BSShapeCollection : IDisposable
         // If not a solid object, body is a GhostObject. Otherwise a RigidBody.
         if (!mustRebuild)
         {
-            CollisionObjectTypes bodyType = (CollisionObjectTypes)PhysicsScene.PE.GetBodyType(prim.PhysBody);
+            CollisionObjectTypes bodyType = (CollisionObjectTypes)m_physicsScene.PE.GetBodyType(prim.PhysBody);
             if (prim.IsSolid && bodyType != CollisionObjectTypes.CO_RIGID_BODY
                 || !prim.IsSolid && bodyType != CollisionObjectTypes.CO_GHOST_OBJECT)
             {
@@ -1047,12 +369,12 @@ public sealed class BSShapeCollection : IDisposable
             BulletBody aBody;
             if (prim.IsSolid)
             {
-                aBody = PhysicsScene.PE.CreateBodyFromShape(sim, prim.PhysShape, prim.LocalID, prim.RawPosition, prim.RawOrientation);
-                if (DDetail) DetailLog("{0},BSShapeCollection.CreateBody,mesh,body={1}", prim.LocalID, aBody);
+                aBody = m_physicsScene.PE.CreateBodyFromShape(sim, prim.PhysShape.physShapeInfo, prim.LocalID, prim.RawPosition, prim.RawOrientation);
+                if (DDetail) DetailLog("{0},BSShapeCollection.CreateBody,rigid,body={1}", prim.LocalID, aBody);
             }
             else
             {
-                aBody = PhysicsScene.PE.CreateGhostFromShape(sim, prim.PhysShape, prim.LocalID, prim.RawPosition, prim.RawOrientation);
+                aBody = m_physicsScene.PE.CreateGhostFromShape(sim, prim.PhysShape.physShapeInfo, prim.LocalID, prim.RawPosition, prim.RawOrientation);
                 if (DDetail) DetailLog("{0},BSShapeCollection.CreateBody,ghost,body={1}", prim.LocalID, aBody);
             }
 
@@ -1066,46 +388,10 @@ public sealed class BSShapeCollection : IDisposable
         return ret;
     }
 
-    private bool TryGetMeshByPtr(BulletShape shape, out MeshDesc outDesc)
-    {
-        bool ret = false;
-        MeshDesc foundDesc = new MeshDesc();
-        foreach (MeshDesc md in Meshes.Values)
-        {
-            if (md.shape.ReferenceSame(shape))
-            {
-                foundDesc = md;
-                ret = true;
-                break;
-            }
-
-        }
-        outDesc = foundDesc;
-        return ret;
-    }
-
-    private bool TryGetHullByPtr(BulletShape shape, out HullDesc outDesc)
-    {
-        bool ret = false;
-        HullDesc foundDesc = new HullDesc();
-        foreach (HullDesc hd in Hulls.Values)
-        {
-            if (hd.shape.ReferenceSame(shape))
-            {
-                foundDesc = hd;
-                ret = true;
-                break;
-            }
-
-        }
-        outDesc = foundDesc;
-        return ret;
-    }
-
     private void DetailLog(string msg, params Object[] args)
     {
-        if (PhysicsScene.PhysicsLogging.Enabled)
-            PhysicsScene.DetailLog(msg, args);
+        if (m_physicsScene.PhysicsLogging.Enabled)
+            m_physicsScene.DetailLog(msg, args);
     }
 }
 }
diff --git a/OpenSim/Region/Physics/BulletSPlugin/BSShapes.cs b/OpenSim/Region/Physics/BulletSPlugin/BSShapes.cs
index ee18379..fe5ff6c 100755
--- a/OpenSim/Region/Physics/BulletSPlugin/BSShapes.cs
+++ b/OpenSim/Region/Physics/BulletSPlugin/BSShapes.cs
@@ -29,115 +29,312 @@ using System;
 using System.Collections.Generic;
 using System.Text;
 
+using OpenSim.Framework;
+using OpenSim.Region.Physics.Manager;
+using OpenSim.Region.Physics.Meshing;
+using OpenSim.Region.Physics.ConvexDecompositionDotNet;
+
 using OMV = OpenMetaverse;
 
 namespace OpenSim.Region.Physics.BulletSPlugin
 {
 public abstract class BSShape
 {
+    private static string LogHeader = "[BULLETSIM SHAPE]";
+
     public int referenceCount { get; set; }
     public DateTime lastReferenced { get; set; }
+    public BulletShape physShapeInfo { get; set; }
 
     public BSShape()
     {
-        referenceCount = 0;
+        referenceCount = 1;
         lastReferenced = DateTime.Now;
+        physShapeInfo = new BulletShape();
     }
-
-    // Get a reference to a physical shape. Create if it doesn't exist
-    public static BSShape GetShapeReference(BSScene physicsScene, bool forceRebuild, BSPhysObject prim)
+    public BSShape(BulletShape pShape)
     {
-        BSShape ret = null;
-
-        if (prim.PreferredPhysicalShape == BSPhysicsShapeType.SHAPE_CAPSULE)
-        {
-            // an avatar capsule is close to a native shape (it is not shared)
-            ret = BSShapeNative.GetReference(physicsScene, prim, BSPhysicsShapeType.SHAPE_CAPSULE,
-                                        FixedShapeKey.KEY_CAPSULE);
-            physicsScene.DetailLog("{0},BSShape.GetShapeReference,avatarCapsule,shape={1}", prim.LocalID, ret);
-        }
-
-        // Compound shapes are handled special as they are rebuilt from scratch.
-        // This isn't too great a hardship since most of the child shapes will have already been created.
-        if (ret == null  && prim.PreferredPhysicalShape == BSPhysicsShapeType.SHAPE_COMPOUND)
-        {
-            // Getting a reference to a compound shape gets you the compound shape with the root prim shape added
-            ret = BSShapeCompound.GetReference(prim);
-            physicsScene.DetailLog("{0},BSShapeCollection.CreateGeom,compoundShape,shape={1}", prim.LocalID, ret);
-        }
-
-        // Avatars have their own unique shape
-        if (ret == null  && prim.PreferredPhysicalShape == BSPhysicsShapeType.SHAPE_AVATAR)
-        {
-            // Getting a reference to a compound shape gets you the compound shape with the root prim shape added
-            ret = BSShapeAvatar.GetReference(prim);
-            physicsScene.DetailLog("{0},BSShapeCollection.CreateGeom,avatarShape,shape={1}", prim.LocalID, ret);
-        }
+        referenceCount = 1;
+        lastReferenced = DateTime.Now;
+        physShapeInfo = pShape;
+    }
 
-        if (ret == null)
-            ret = GetShapeReferenceNonSpecial(physicsScene, forceRebuild, prim);
+    // Get another reference to this shape.
+    public abstract BSShape GetReference(BSScene pPhysicsScene, BSPhysObject pPrim);
 
-        return ret;
-    }
-    public static BSShape GetShapeReferenceNonSpecial(BSScene physicsScene, bool forceRebuild, BSPhysObject prim)
+    // Called when this shape is being used again.
+    // Used internally. External callers should call instance.GetReference() to properly copy/reference
+    //       the shape.
+    protected virtual void IncrementReference()
     {
-        return null;
+        referenceCount++;
+        lastReferenced = DateTime.Now;
     }
-    public static BSShape GetShapeReferenceNonNative(BSScene physicsScene, bool forceRebuild, BSPhysObject prim)
+
+    // Called when this shape is done being used.
+    protected virtual void DecrementReference()
     {
-        return null;
+        referenceCount--;
+        lastReferenced = DateTime.Now;
     }
 
     // Release the use of a physical shape.
     public abstract void Dereference(BSScene physicsScene);
 
-    // All shapes have a static call to get a reference to the physical shape
-    // protected abstract static BSShape GetReference();
+    // Return 'true' if there is an allocated physics physical shape under this class instance.
+    public virtual bool HasPhysicalShape
+    {
+        get
+        {
+            if (physShapeInfo != null)
+                return physShapeInfo.HasPhysicalShape;
+            return false;
+        }
+    }
+    public virtual BSPhysicsShapeType ShapeType
+    {
+        get
+        {
+            BSPhysicsShapeType ret = BSPhysicsShapeType.SHAPE_UNKNOWN;
+            if (physShapeInfo != null && physShapeInfo.HasPhysicalShape)
+                ret = physShapeInfo.shapeType;
+            return ret;
+        }
+    }
 
     // Returns a string for debugging that uniquily identifies the memory used by this instance
     public virtual string AddrString
     {
-        get { return "unknown"; }
+        get
+        {
+            if (physShapeInfo != null)
+                return physShapeInfo.AddrString;
+            return "unknown";
+        }
     }
 
     public override string ToString()
     {
         StringBuilder buff = new StringBuilder();
-        buff.Append("<p=");
-        buff.Append(AddrString);
+        if (physShapeInfo == null)
+        {
+            buff.Append("<noPhys");
+        }
+        else
+        {
+            buff.Append("<phy=");
+            buff.Append(physShapeInfo.ToString());
+        }
         buff.Append(",c=");
         buff.Append(referenceCount.ToString());
         buff.Append(">");
         return buff.ToString();
     }
+
+    #region Common shape routines
+    // Create a hash of all the shape parameters to be used as a key for this particular shape.
+    public static System.UInt64 ComputeShapeKey(OMV.Vector3 size, PrimitiveBaseShape pbs, out float retLod)
+    {
+        // level of detail based on size and type of the object
+        float lod = BSParam.MeshLOD;
+        if (pbs.SculptEntry)
+            lod = BSParam.SculptLOD;
+
+        // Mega prims usually get more detail because one can interact with shape approximations at this size.
+        float maxAxis = Math.Max(size.X, Math.Max(size.Y, size.Z));
+        if (maxAxis > BSParam.MeshMegaPrimThreshold)
+            lod = BSParam.MeshMegaPrimLOD;
+
+        retLod = lod;
+        return pbs.GetMeshKey(size, lod);
+    }
+
+    // The creation of a mesh or hull can fail if an underlying asset is not available.
+    // There are two cases: 1) the asset is not in the cache and it needs to be fetched;
+    //     and 2) the asset cannot be converted (like failed decompression of JPEG2000s).
+    //     The first case causes the asset to be fetched. The second case requires
+    //     us to not loop forever.
+    // Called after creating a physical mesh or hull. If the physical shape was created,
+    //     just return.
+    public static BulletShape VerifyMeshCreated(BSScene physicsScene, BulletShape newShape, BSPhysObject prim)
+    {
+        // If the shape was successfully created, nothing more to do
+        if (newShape.HasPhysicalShape)
+            return newShape;
+
+        // VerifyMeshCreated is called after trying to create the mesh. If we think the asset had been
+        //    fetched but we end up here again, the meshing of the asset must have failed.
+        // Prevent trying to keep fetching the mesh by declaring failure.
+        if (prim.PrimAssetState == BSPhysObject.PrimAssetCondition.Fetched)
+        {
+            prim.PrimAssetState = BSPhysObject.PrimAssetCondition.FailedMeshing;
+            physicsScene.Logger.WarnFormat("{0} Fetched asset would not mesh. prim={1}, texture={2}",
+                                            LogHeader, UsefulPrimInfo(physicsScene, prim), prim.BaseShape.SculptTexture);
+            physicsScene.DetailLog("{0},BSShape.VerifyMeshCreated,setFailed,prim={1},tex={2}",
+                                            prim.LocalID, UsefulPrimInfo(physicsScene, prim), prim.BaseShape.SculptTexture);
+        }
+        else
+        {
+            // If this mesh has an underlying asset and we have not failed getting it before, fetch the asset
+            if (prim.BaseShape.SculptEntry
+                && prim.PrimAssetState != BSPhysObject.PrimAssetCondition.FailedAssetFetch
+                && prim.PrimAssetState != BSPhysObject.PrimAssetCondition.FailedMeshing
+                && prim.PrimAssetState != BSPhysObject.PrimAssetCondition.Waiting
+                && prim.BaseShape.SculptTexture != OMV.UUID.Zero
+                )
+            {
+                physicsScene.DetailLog("{0},BSShape.VerifyMeshCreated,fetchAsset,objNam={1},tex={2}",
+                                            prim.LocalID, prim.PhysObjectName, prim.BaseShape.SculptTexture);
+                // Multiple requestors will know we're waiting for this asset
+                prim.PrimAssetState = BSPhysObject.PrimAssetCondition.Waiting;
+
+                BSPhysObject xprim = prim;
+                Util.FireAndForget(delegate
+                    {
+                        // physicsScene.DetailLog("{0},BSShape.VerifyMeshCreated,inFireAndForget", xprim.LocalID);
+                        RequestAssetDelegate assetProvider = physicsScene.RequestAssetMethod;
+                        if (assetProvider != null)
+                        {
+                            BSPhysObject yprim = xprim; // probably not necessary, but, just in case.
+                            assetProvider(yprim.BaseShape.SculptTexture, delegate(AssetBase asset)
+                            {
+                                // physicsScene.DetailLog("{0},BSShape.VerifyMeshCreated,assetProviderCallback", xprim.LocalID);
+                                bool assetFound = false;
+                                string mismatchIDs = String.Empty;  // DEBUG DEBUG
+                                if (asset != null && yprim.BaseShape.SculptEntry)
+                                {
+                                    if (yprim.BaseShape.SculptTexture.ToString() == asset.ID)
+                                    {
+                                        yprim.BaseShape.SculptData = asset.Data;
+                                        // This will cause the prim to see that the filler shape is not the right
+                                        //    one and try again to build the object.
+                                        // No race condition with the normal shape setting since the rebuild is at taint time.
+                                        yprim.PrimAssetState = BSPhysObject.PrimAssetCondition.Fetched;
+                                        yprim.ForceBodyShapeRebuild(false /* inTaintTime */);
+                                        assetFound = true;
+                                    }
+                                    else
+                                    {
+                                        mismatchIDs = yprim.BaseShape.SculptTexture.ToString() + "/" + asset.ID;
+                                    }
+                                }
+                                if (!assetFound)
+                                {
+                                    yprim.PrimAssetState = BSPhysObject.PrimAssetCondition.FailedAssetFetch;
+                                }
+                                physicsScene.DetailLog("{0},BSShape.VerifyMeshCreated,fetchAssetCallback,found={1},isSculpt={2},ids={3}",
+                                            yprim.LocalID, assetFound, yprim.BaseShape.SculptEntry, mismatchIDs );
+                            });
+                        }
+                        else
+                        {
+                            xprim.PrimAssetState = BSPhysObject.PrimAssetCondition.FailedAssetFetch;
+                            physicsScene.Logger.ErrorFormat("{0} Physical object requires asset but no asset provider. Name={1}",
+                                                        LogHeader, physicsScene.Name);
+                        }
+                    });
+            }
+            else
+            {
+                if (prim.PrimAssetState == BSPhysObject.PrimAssetCondition.FailedAssetFetch)
+                {
+                    physicsScene.Logger.WarnFormat("{0} Mesh failed to fetch asset. prim={1}, texture={2}",
+                                                LogHeader, UsefulPrimInfo(physicsScene, prim), prim.BaseShape.SculptTexture);
+                    physicsScene.DetailLog("{0},BSShape.VerifyMeshCreated,wasFailed,prim={1},tex={2}",
+                                                prim.LocalID, UsefulPrimInfo(physicsScene, prim), prim.BaseShape.SculptTexture);
+                }
+                if (prim.PrimAssetState == BSPhysObject.PrimAssetCondition.FailedMeshing)
+                {
+                    physicsScene.Logger.WarnFormat("{0} Mesh asset would not mesh. prim={1}, texture={2}",
+                                                LogHeader, UsefulPrimInfo(physicsScene, prim), prim.BaseShape.SculptTexture);
+                    physicsScene.DetailLog("{0},BSShape.VerifyMeshCreated,wasFailedMeshing,prim={1},tex={2}",
+                                                prim.LocalID, UsefulPrimInfo(physicsScene, prim), prim.BaseShape.SculptTexture);
+                }
+            }
+         }
+
+        // While we wait for the mesh defining asset to be loaded, stick in a simple box for the object.
+        BSShape fillShape = BSShapeNative.GetReference(physicsScene, prim, BSPhysicsShapeType.SHAPE_BOX, FixedShapeKey.KEY_BOX);
+        physicsScene.DetailLog("{0},BSShape.VerifyMeshCreated,boxTempShape", prim.LocalID);
+
+        return fillShape.physShapeInfo;
+     }
+
+    public static String UsefulPrimInfo(BSScene pScene, BSPhysObject prim)
+    {
+        StringBuilder buff = new StringBuilder(prim.PhysObjectName);
+        buff.Append("/pos=");
+        buff.Append(prim.RawPosition.ToString());
+        if (pScene != null)
+        {
+            buff.Append("/rgn=");
+            buff.Append(pScene.Name);
+        }
+        return buff.ToString();
+    }
+
+    #endregion // Common shape routines
 }
 
+// ============================================================================================================
 public class BSShapeNull : BSShape
 {
     public BSShapeNull() : base()
     {
     }
     public static BSShape GetReference() { return new BSShapeNull();  }
+    public override BSShape GetReference(BSScene pPhysicsScene, BSPhysObject pPrim) { return new BSShapeNull();  }
     public override void Dereference(BSScene physicsScene) { /* The magic of garbage collection will make this go away */ }
 }
 
+// ============================================================================================================
 public class BSShapeNative : BSShape
 {
     private static string LogHeader = "[BULLETSIM SHAPE NATIVE]";
-    public BSShapeNative() : base()
+    public BSShapeNative(BulletShape pShape) : base(pShape)
     {
     }
-    public static BSShape GetReference(BSScene physicsScene, BSPhysObject prim, 
-                    BSPhysicsShapeType shapeType, FixedShapeKey shapeKey) 
+
+    public static BSShape GetReference(BSScene physicsScene, BSPhysObject prim,
+                                            BSPhysicsShapeType shapeType, FixedShapeKey shapeKey)
     {
         // Native shapes are not shared and are always built anew.
-        //return new BSShapeNative(physicsScene, prim, shapeType, shapeKey);
-        return null;
+        return new BSShapeNative(CreatePhysicalNativeShape(physicsScene, prim, shapeType, shapeKey));
     }
 
-    private BSShapeNative(BSScene physicsScene, BSPhysObject prim,
-                    BSPhysicsShapeType shapeType, FixedShapeKey shapeKey)
+    public override BSShape GetReference(BSScene pPhysicsScene, BSPhysObject pPrim)
     {
+        // Native shapes are not shared so we return a new shape.
+        BSShape ret = null;
+        lock (physShapeInfo)
+        {
+            ret = new BSShapeNative(CreatePhysicalNativeShape(pPhysicsScene, pPrim,
+                                        physShapeInfo.shapeType, (FixedShapeKey)physShapeInfo.shapeKey));
+        }
+        return ret;
+    }
+
+    // Make this reference to the physical shape go away since native shapes are not shared.
+    public override void Dereference(BSScene physicsScene)
+    {
+        // Native shapes are not tracked and are released immediately
+        lock (physShapeInfo)
+        {
+            if (physShapeInfo.HasPhysicalShape)
+            {
+                physicsScene.DetailLog("{0},BSShapeNative.Dereference,deleteNativeShape,shape={1}", BSScene.DetailLogZero, this);
+                physicsScene.PE.DeleteCollisionShape(physicsScene.World, physShapeInfo);
+            }
+            physShapeInfo.Clear();
+            // Garbage collection will free up this instance.
+        }
+    }
+
+    private static BulletShape CreatePhysicalNativeShape(BSScene physicsScene, BSPhysObject prim,
+                                            BSPhysicsShapeType shapeType, FixedShapeKey shapeKey)
+    {
+        BulletShape newShape;
+
         ShapeData nativeShapeData = new ShapeData();
         nativeShapeData.Type = shapeType;
         nativeShapeData.ID = prim.LocalID;
@@ -146,84 +343,880 @@ public class BSShapeNative : BSShape
         nativeShapeData.MeshKey = (ulong)shapeKey;
         nativeShapeData.HullKey = (ulong)shapeKey;
 
-       
-        /*
         if (shapeType == BSPhysicsShapeType.SHAPE_CAPSULE)
         {
-            ptr = PhysicsScene.PE.BuildCapsuleShape(physicsScene.World, 1f, 1f, prim.Scale);
-            physicsScene.DetailLog("{0},BSShapeCollection.BuiletPhysicalNativeShape,capsule,scale={1}", prim.LocalID, prim.Scale);
+            newShape = physicsScene.PE.BuildCapsuleShape(physicsScene.World, 1f, 1f, prim.Scale);
+            physicsScene.DetailLog("{0},BSShapeNative,capsule,scale={1}", prim.LocalID, prim.Scale);
         }
         else
         {
-            ptr = PhysicsScene.PE.BuildNativeShape(physicsScene.World, nativeShapeData);
+            newShape = physicsScene.PE.BuildNativeShape(physicsScene.World, nativeShapeData);
         }
-        if (ptr == IntPtr.Zero)
+        if (!newShape.HasPhysicalShape)
         {
             physicsScene.Logger.ErrorFormat("{0} BuildPhysicalNativeShape failed. ID={1}, shape={2}",
                                     LogHeader, prim.LocalID, shapeType);
         }
-        type = shapeType;
-        key = (UInt64)shapeKey;
-         */
-    }
-    // Make this reference to the physical shape go away since native shapes are not shared.
-    public override void Dereference(BSScene physicsScene)
-    {
-        /*
-        // Native shapes are not tracked and are released immediately
-        physicsScene.DetailLog("{0},BSShapeCollection.DereferenceShape,deleteNativeShape,shape={1}", BSScene.DetailLogZero, this);
-        PhysicsScene.PE.DeleteCollisionShape(physicsScene.World, this);
-        ptr = IntPtr.Zero;
-        // Garbage collection will free up this instance.
-         */
+        newShape.shapeType = shapeType;
+        newShape.isNativeShape = true;
+        newShape.shapeKey = (UInt64)shapeKey;
+        return newShape;
     }
+
 }
 
+// ============================================================================================================
 public class BSShapeMesh : BSShape
 {
     private static string LogHeader = "[BULLETSIM SHAPE MESH]";
-    private static Dictionary<System.UInt64, BSShapeMesh> Meshes = new Dictionary<System.UInt64, BSShapeMesh>();
+    public static Dictionary<System.UInt64, BSShapeMesh> Meshes = new Dictionary<System.UInt64, BSShapeMesh>();
 
-    public BSShapeMesh() : base()
+    public BSShapeMesh(BulletShape pShape) : base(pShape)
     {
     }
-    public static BSShape GetReference() { return new BSShapeNull();  }
-    public override void Dereference(BSScene physicsScene) { }
+    public static BSShape GetReference(BSScene physicsScene, bool forceRebuild, BSPhysObject prim)
+    {
+        float lod;
+        System.UInt64 newMeshKey = BSShape.ComputeShapeKey(prim.Size, prim.BaseShape, out lod);
+
+        BSShapeMesh retMesh = null;
+        lock (Meshes)
+        {
+            if (Meshes.TryGetValue(newMeshKey, out retMesh))
+            {
+                // The mesh has already been created. Return a new reference to same.
+                retMesh.IncrementReference();
+            }
+            else
+            {
+                retMesh = new BSShapeMesh(new BulletShape());
+                // An instance of this mesh has not been created. Build and remember same.
+                BulletShape newShape = retMesh.CreatePhysicalMesh(physicsScene, prim, newMeshKey, prim.BaseShape, prim.Size, lod);
+
+                // Check to see if mesh was created (might require an asset).
+                newShape = VerifyMeshCreated(physicsScene, newShape, prim);
+                if (!newShape.isNativeShape
+                            || prim.PrimAssetState == BSPhysObject.PrimAssetCondition.FailedMeshing
+                            || prim.PrimAssetState == BSPhysObject.PrimAssetCondition.FailedAssetFetch)
+                {
+                    // If a mesh was what was created, remember the built shape for later sharing.
+                    // Also note that if meshing failed we put it in the mesh list as there is nothing else to do about the mesh.
+                    Meshes.Add(newMeshKey, retMesh);
+                }
+
+                retMesh.physShapeInfo = newShape;
+            }
+        }
+        physicsScene.DetailLog("{0},BSShapeMesh,getReference,mesh={1},size={2},lod={3}", prim.LocalID, retMesh, prim.Size, lod);
+        return retMesh;
+    }
+    public override BSShape GetReference(BSScene pPhysicsScene, BSPhysObject pPrim)
+    {
+        BSShape ret = null;
+        // If the underlying shape is native, the actual shape has not been build (waiting for asset)
+        //     and we must create a copy of the native shape since they are never shared.
+        if (physShapeInfo.HasPhysicalShape && physShapeInfo.isNativeShape)
+        {
+            // TODO: decide when the native shapes should be freed. Check in Dereference?
+            ret = BSShapeNative.GetReference(pPhysicsScene, pPrim, BSPhysicsShapeType.SHAPE_BOX, FixedShapeKey.KEY_BOX);
+        }
+        else
+        {
+            // Another reference to this shape is just counted.
+            IncrementReference();
+            ret = this;
+        }
+        return ret;
+    }
+    public override void Dereference(BSScene physicsScene)
+    {
+        lock (Meshes)
+        {
+            this.DecrementReference();
+            physicsScene.DetailLog("{0},BSShapeMesh.Dereference,shape={1}", BSScene.DetailLogZero, this);
+            // TODO: schedule aging and destruction of unused meshes.
+        }
+    }
+    // Loop through all the known meshes and return the description based on the physical address.
+    public static bool TryGetMeshByPtr(BulletShape pShape, out BSShapeMesh outMesh)
+    {
+        bool ret = false;
+        BSShapeMesh foundDesc = null;
+        lock (Meshes)
+        {
+            foreach (BSShapeMesh sm in Meshes.Values)
+            {
+                if (sm.physShapeInfo.ReferenceSame(pShape))
+                {
+                    foundDesc = sm;
+                    ret = true;
+                    break;
+                }
+
+            }
+        }
+        outMesh = foundDesc;
+        return ret;
+    }
+
+    public delegate BulletShape CreateShapeCall(BulletWorld world, int indicesCount, int[] indices, int verticesCount, float[] vertices );
+    private BulletShape CreatePhysicalMesh(BSScene physicsScene, BSPhysObject prim, System.UInt64 newMeshKey,
+                                            PrimitiveBaseShape pbs, OMV.Vector3 size, float lod)
+    {
+        return BSShapeMesh.CreatePhysicalMeshShape(physicsScene, prim, newMeshKey, pbs, size, lod,
+                            (w, iC, i, vC, v) => physicsScene.PE.CreateMeshShape(w, iC, i, vC, v) );
+    }
+
+    // Code that uses the mesher to create the index/vertices info for a trimesh shape.
+    // This is used by the passed 'makeShape' call to create the Bullet mesh shape.
+    // The actual build call is passed so this logic can be used by several of the shapes that use a
+    //     simple mesh as their base shape.
+    public static BulletShape CreatePhysicalMeshShape(BSScene physicsScene, BSPhysObject prim, System.UInt64 newMeshKey,
+                                            PrimitiveBaseShape pbs, OMV.Vector3 size, float lod, CreateShapeCall makeShape)
+    {
+        BulletShape newShape = new BulletShape();
+
+        IMesh meshData = null;
+        lock (physicsScene.mesher)
+        {
+            meshData = physicsScene.mesher.CreateMesh(prim.PhysObjectName, pbs, size, lod,
+                                            false,  // say it is not physical so a bounding box is not built
+                                            false,   // do not cache the mesh and do not use previously built versions
+                                            false,
+                                            false
+                                            );
+        }
+
+        if (meshData != null)
+        {
+            if (prim.PrimAssetState == BSPhysObject.PrimAssetCondition.Fetched)
+            {
+                // Release the fetched asset data once it has been used.
+                pbs.SculptData = new byte[0];
+                prim.PrimAssetState = BSPhysObject.PrimAssetCondition.Unknown;
+            }
+
+            int[] indices = meshData.getIndexListAsInt();
+            int realIndicesIndex = indices.Length;
+            float[] verticesAsFloats = meshData.getVertexListAsFloat();
+
+            if (BSParam.ShouldRemoveZeroWidthTriangles)
+            {
+                // Remove degenerate triangles. These are triangles with two of the vertices
+                //    are the same. This is complicated by the problem that vertices are not
+                //    made unique in sculpties so we have to compare the values in the vertex.
+                realIndicesIndex = 0;
+                for (int tri = 0; tri < indices.Length; tri += 3)
+                {
+                    // Compute displacements into vertex array for each vertex of the triangle
+                    int v1 = indices[tri + 0] * 3;
+                    int v2 = indices[tri + 1] * 3;
+                    int v3 = indices[tri + 2] * 3;
+                // Check to see if any two of the vertices are the same
+                    if (!( (  verticesAsFloats[v1 + 0] == verticesAsFloats[v2 + 0]
+                           && verticesAsFloats[v1 + 1] == verticesAsFloats[v2 + 1]
+                           && verticesAsFloats[v1 + 2] == verticesAsFloats[v2 + 2])
+                        || (  verticesAsFloats[v2 + 0] == verticesAsFloats[v3 + 0]
+                           && verticesAsFloats[v2 + 1] == verticesAsFloats[v3 + 1]
+                           && verticesAsFloats[v2 + 2] == verticesAsFloats[v3 + 2])
+                        || (  verticesAsFloats[v1 + 0] == verticesAsFloats[v3 + 0]
+                           && verticesAsFloats[v1 + 1] == verticesAsFloats[v3 + 1]
+                           && verticesAsFloats[v1 + 2] == verticesAsFloats[v3 + 2]) )
+                    )
+                    {
+                        // None of the vertices of the triangles are the same. This is a good triangle;
+                        indices[realIndicesIndex + 0] = indices[tri + 0];
+                        indices[realIndicesIndex + 1] = indices[tri + 1];
+                        indices[realIndicesIndex + 2] = indices[tri + 2];
+                        realIndicesIndex += 3;
+                    }
+                }
+            }
+            physicsScene.DetailLog("{0},BSShapeMesh.CreatePhysicalMesh,key={1},origTri={2},realTri={3},numVerts={4}",
+                        BSScene.DetailLogZero, newMeshKey.ToString("X"), indices.Length / 3, realIndicesIndex / 3, verticesAsFloats.Length / 3);
+
+            if (realIndicesIndex != 0)
+            {
+                newShape = makeShape(physicsScene.World, realIndicesIndex, indices, verticesAsFloats.Length / 3, verticesAsFloats);
+            }
+            else
+            {
+                // Force the asset condition to 'failed' so we won't try to keep fetching and processing this mesh.
+                prim.PrimAssetState = BSPhysObject.PrimAssetCondition.FailedMeshing;
+                physicsScene.Logger.DebugFormat("{0} All mesh triangles degenerate. Prim={1}", LogHeader, UsefulPrimInfo(physicsScene, prim) );
+                physicsScene.DetailLog("{0},BSShapeMesh.CreatePhysicalMesh,allDegenerate,key={1}", prim.LocalID, newMeshKey);
+            }
+        }
+        newShape.shapeKey = newMeshKey;
+
+        return newShape;
+    }
 }
 
+// ============================================================================================================
 public class BSShapeHull : BSShape
 {
     private static string LogHeader = "[BULLETSIM SHAPE HULL]";
-    private static Dictionary<System.UInt64, BSShapeHull> Hulls = new Dictionary<System.UInt64, BSShapeHull>();
+    public static Dictionary<System.UInt64, BSShapeHull> Hulls = new Dictionary<System.UInt64, BSShapeHull>();
 
-    public BSShapeHull() : base()
+    public BSShapeHull(BulletShape pShape) : base(pShape)
     {
     }
-    public static BSShape GetReference() { return new BSShapeNull();  }
-    public override void Dereference(BSScene physicsScene) { }
+    public static BSShape GetReference(BSScene physicsScene, bool forceRebuild, BSPhysObject prim)
+    {
+        float lod;
+        System.UInt64 newHullKey = BSShape.ComputeShapeKey(prim.Size, prim.BaseShape, out lod);
+
+        BSShapeHull retHull = null;
+        lock (Hulls)
+        {
+            if (Hulls.TryGetValue(newHullKey, out retHull))
+            {
+                // The mesh has already been created. Return a new reference to same.
+                retHull.IncrementReference();
+            }
+            else
+            {
+                retHull = new BSShapeHull(new BulletShape());
+                // An instance of this mesh has not been created. Build and remember same.
+                BulletShape newShape = retHull.CreatePhysicalHull(physicsScene, prim, newHullKey, prim.BaseShape, prim.Size, lod);
+
+                // Check to see if hull was created (might require an asset).
+                newShape = VerifyMeshCreated(physicsScene, newShape, prim);
+                if (!newShape.isNativeShape
+                            || prim.PrimAssetState == BSPhysObject.PrimAssetCondition.FailedMeshing
+                            || prim.PrimAssetState == BSPhysObject.PrimAssetCondition.FailedAssetFetch)
+                {
+                    // If a mesh was what was created, remember the built shape for later sharing.
+                    Hulls.Add(newHullKey, retHull);
+                }
+                retHull.physShapeInfo = newShape;
+            }
+        }
+        physicsScene.DetailLog("{0},BSShapeHull,getReference,hull={1},size={2},lod={3}", prim.LocalID, retHull, prim.Size, lod);
+        return retHull;
+    }
+    public override BSShape GetReference(BSScene pPhysicsScene, BSPhysObject pPrim)
+    {
+        BSShape ret = null;
+        // If the underlying shape is native, the actual shape has not been build (waiting for asset)
+        //     and we must create a copy of the native shape since they are never shared.
+        if (physShapeInfo.HasPhysicalShape && physShapeInfo.isNativeShape)
+        {
+            // TODO: decide when the native shapes should be freed. Check in Dereference?
+            ret = BSShapeNative.GetReference(pPhysicsScene, pPrim, BSPhysicsShapeType.SHAPE_BOX, FixedShapeKey.KEY_BOX);
+        }
+        else
+        {
+            // Another reference to this shape is just counted.
+            IncrementReference();
+            ret = this;
+        }
+        return ret;
+    }
+    public override void Dereference(BSScene physicsScene)
+    {
+        lock (Hulls)
+        {
+            this.DecrementReference();
+            physicsScene.DetailLog("{0},BSShapeHull.Dereference,shape={1}", BSScene.DetailLogZero, this);
+            // TODO: schedule aging and destruction of unused meshes.
+        }
+    }
+    List<ConvexResult> m_hulls;
+    private BulletShape CreatePhysicalHull(BSScene physicsScene, BSPhysObject prim, System.UInt64 newHullKey,
+                                            PrimitiveBaseShape pbs, OMV.Vector3 size, float lod)
+    {
+        BulletShape newShape = new BulletShape();
+
+        IMesh meshData = null;
+        List<List<OMV.Vector3>> allHulls = null;
+        lock (physicsScene.mesher)
+        {
+            // Pass true for physicalness as this prevents the creation of bounding box which is not needed
+            meshData = physicsScene.mesher.CreateMesh(prim.PhysObjectName, pbs, size, lod, true /* isPhysical */, false /* shouldCache */, false, false);
+
+            // If we should use the asset's hull info, fetch it out of the locked mesher
+            if (meshData != null && BSParam.ShouldUseAssetHulls)
+            {
+                Meshmerizer realMesher = physicsScene.mesher as Meshmerizer;
+                if (realMesher != null)
+                {
+                    allHulls = realMesher.GetConvexHulls(size);
+                }
+                if (allHulls == null)
+                {
+                    physicsScene.DetailLog("{0},BSShapeHull.CreatePhysicalHull,assetHulls,noAssetHull", prim.LocalID);
+                }
+            }
+        }
+
+        // If there is hull data in the mesh asset, build the hull from that
+        if (allHulls != null && BSParam.ShouldUseAssetHulls)
+        {
+            int hullCount = allHulls.Count;
+            int totalVertices = 1;      // include one for the count of the hulls
+            // Using the structure described for HACD hulls, create the memory sturcture
+            //     to pass the hull data to the creater.
+            foreach (List<OMV.Vector3> hullVerts in allHulls)
+            {
+                totalVertices += 4;                     // add four for the vertex count and centroid
+                totalVertices += hullVerts.Count * 3;   // one vertex is three dimensions
+            }
+            float[] convHulls = new float[totalVertices];
+
+            convHulls[0] = (float)hullCount;
+            int jj = 1;
+            foreach (List<OMV.Vector3> hullVerts in allHulls)
+            {
+                convHulls[jj + 0] = hullVerts.Count;
+                convHulls[jj + 1] = 0f;   // centroid x,y,z
+                convHulls[jj + 2] = 0f;
+                convHulls[jj + 3] = 0f;
+                jj += 4;
+                foreach (OMV.Vector3 oneVert in hullVerts)
+                {
+                    convHulls[jj + 0] = oneVert.X;
+                    convHulls[jj + 1] = oneVert.Y;
+                    convHulls[jj + 2] = oneVert.Z;
+                    jj += 3;
+                }
+            }
+
+            // create the hull data structure in Bullet
+            newShape = physicsScene.PE.CreateHullShape(physicsScene.World, hullCount, convHulls);
+
+            physicsScene.DetailLog("{0},BSShapeHull.CreatePhysicalHull,assetHulls,hulls={1},totVert={2},shape={3}",
+                                        prim.LocalID, hullCount, totalVertices, newShape);
+        }
+
+        // If no hull specified in the asset and we should use Bullet's HACD approximation...
+        if (!newShape.HasPhysicalShape && BSParam.ShouldUseBulletHACD)
+        {
+            // Build the hull shape from an existing mesh shape.
+            // The mesh should have already been created in Bullet.
+            physicsScene.DetailLog("{0},BSShapeHull.CreatePhysicalHull,bulletHACD,entry", prim.LocalID);
+            BSShape meshShape = BSShapeMesh.GetReference(physicsScene, true, prim);
+
+            if (meshShape.physShapeInfo.HasPhysicalShape)
+            {
+                HACDParams parms;
+                parms.maxVerticesPerHull = BSParam.BHullMaxVerticesPerHull;
+                parms.minClusters = BSParam.BHullMinClusters;
+                parms.compacityWeight = BSParam.BHullCompacityWeight;
+                parms.volumeWeight = BSParam.BHullVolumeWeight;
+                parms.concavity = BSParam.BHullConcavity;
+                parms.addExtraDistPoints = BSParam.NumericBool(BSParam.BHullAddExtraDistPoints);
+                parms.addNeighboursDistPoints = BSParam.NumericBool(BSParam.BHullAddNeighboursDistPoints);
+                parms.addFacesPoints = BSParam.NumericBool(BSParam.BHullAddFacesPoints);
+                parms.shouldAdjustCollisionMargin = BSParam.NumericBool(BSParam.BHullShouldAdjustCollisionMargin);
+
+                physicsScene.DetailLog("{0},BSShapeHull.CreatePhysicalHull,hullFromMesh,beforeCall", prim.LocalID, newShape.HasPhysicalShape);
+                newShape = physicsScene.PE.BuildHullShapeFromMesh(physicsScene.World, meshShape.physShapeInfo, parms);
+                physicsScene.DetailLog("{0},BSShapeHull.CreatePhysicalHull,hullFromMesh,shape={1}", prim.LocalID, newShape);
+
+                // Now done with the mesh shape.
+                meshShape.Dereference(physicsScene);
+            }
+            physicsScene.DetailLog("{0},BSShapeHull.CreatePhysicalHull,bulletHACD,exit,hasBody={1}", prim.LocalID, newShape.HasPhysicalShape);
+        }
+
+        // If no other hull specifications, use our HACD hull approximation.
+        if (!newShape.HasPhysicalShape && meshData != null)
+        {
+            if (prim.PrimAssetState == BSPhysObject.PrimAssetCondition.Fetched)
+            {
+                // Release the fetched asset data once it has been used.
+                pbs.SculptData = new byte[0];
+                prim.PrimAssetState = BSPhysObject.PrimAssetCondition.Unknown;
+            }
+
+            int[] indices = meshData.getIndexListAsInt();
+            List<OMV.Vector3> vertices = meshData.getVertexList();
+
+            //format conversion from IMesh format to DecompDesc format
+            List<int> convIndices = new List<int>();
+            List<float3> convVertices = new List<float3>();
+            for (int ii = 0; ii < indices.GetLength(0); ii++)
+            {
+                convIndices.Add(indices[ii]);
+            }
+            foreach (OMV.Vector3 vv in vertices)
+            {
+                convVertices.Add(new float3(vv.X, vv.Y, vv.Z));
+            }
+
+            uint maxDepthSplit = (uint)BSParam.CSHullMaxDepthSplit;
+            if (BSParam.CSHullMaxDepthSplit != BSParam.CSHullMaxDepthSplitForSimpleShapes)
+            {
+                // Simple primitive shapes we know are convex so they are better implemented with
+                //    fewer hulls.
+                // Check for simple shape (prim without cuts) and reduce split parameter if so.
+                if (BSShapeCollection.PrimHasNoCuts(pbs))
+                {
+                    maxDepthSplit = (uint)BSParam.CSHullMaxDepthSplitForSimpleShapes;
+                }
+            }
+
+            // setup and do convex hull conversion
+            m_hulls = new List<ConvexResult>();
+            DecompDesc dcomp = new DecompDesc();
+            dcomp.mIndices = convIndices;
+            dcomp.mVertices = convVertices;
+            dcomp.mDepth = maxDepthSplit;
+            dcomp.mCpercent = BSParam.CSHullConcavityThresholdPercent;
+            dcomp.mPpercent = BSParam.CSHullVolumeConservationThresholdPercent;
+            dcomp.mMaxVertices = (uint)BSParam.CSHullMaxVertices;
+            dcomp.mSkinWidth = BSParam.CSHullMaxSkinWidth;
+            ConvexBuilder convexBuilder = new ConvexBuilder(HullReturn);
+            // create the hull into the _hulls variable
+            convexBuilder.process(dcomp);
+
+            physicsScene.DetailLog("{0},BSShapeCollection.CreatePhysicalHull,key={1},inVert={2},inInd={3},split={4},hulls={5}",
+                                BSScene.DetailLogZero, newHullKey, indices.GetLength(0), vertices.Count, maxDepthSplit, m_hulls.Count);
+
+            // Convert the vertices and indices for passing to unmanaged.
+            // The hull information is passed as a large floating point array.
+            // The format is:
+            //  convHulls[0] = number of hulls
+            //  convHulls[1] = number of vertices in first hull
+            //  convHulls[2] = hull centroid X coordinate
+            //  convHulls[3] = hull centroid Y coordinate
+            //  convHulls[4] = hull centroid Z coordinate
+            //  convHulls[5] = first hull vertex X
+            //  convHulls[6] = first hull vertex Y
+            //  convHulls[7] = first hull vertex Z
+            //  convHulls[8] = second hull vertex X
+            //  ...
+            //  convHulls[n] = number of vertices in second hull
+            //  convHulls[n+1] = second hull centroid X coordinate
+            //  ...
+            //
+            // TODO: is is very inefficient. Someday change the convex hull generator to return
+            //   data structures that do not need to be converted in order to pass to Bullet.
+            //   And maybe put the values directly into pinned memory rather than marshaling.
+            int hullCount = m_hulls.Count;
+            int totalVertices = 1;          // include one for the count of the hulls
+            foreach (ConvexResult cr in m_hulls)
+            {
+                totalVertices += 4;                         // add four for the vertex count and centroid
+                totalVertices += cr.HullIndices.Count * 3;  // we pass just triangles
+            }
+            float[] convHulls = new float[totalVertices];
+
+            convHulls[0] = (float)hullCount;
+            int jj = 1;
+            foreach (ConvexResult cr in m_hulls)
+            {
+                // copy vertices for index access
+                float3[] verts = new float3[cr.HullVertices.Count];
+                int kk = 0;
+                foreach (float3 ff in cr.HullVertices)
+                {
+                    verts[kk++] = ff;
+                }
+
+                // add to the array one hull's worth of data
+                convHulls[jj++] = cr.HullIndices.Count;
+                convHulls[jj++] = 0f;   // centroid x,y,z
+                convHulls[jj++] = 0f;
+                convHulls[jj++] = 0f;
+                foreach (int ind in cr.HullIndices)
+                {
+                    convHulls[jj++] = verts[ind].x;
+                    convHulls[jj++] = verts[ind].y;
+                    convHulls[jj++] = verts[ind].z;
+                }
+            }
+            // create the hull data structure in Bullet
+            newShape = physicsScene.PE.CreateHullShape(physicsScene.World, hullCount, convHulls);
+        }
+        newShape.shapeKey = newHullKey;
+        return newShape;
+    }
+    // Callback from convex hull creater with a newly created hull.
+    // Just add it to our collection of hulls for this shape.
+    private void HullReturn(ConvexResult result)
+    {
+        m_hulls.Add(result);
+        return;
+    }
+    // Loop through all the known hulls and return the description based on the physical address.
+    public static bool TryGetHullByPtr(BulletShape pShape, out BSShapeHull outHull)
+    {
+        bool ret = false;
+        BSShapeHull foundDesc = null;
+        lock (Hulls)
+        {
+            foreach (BSShapeHull sh in Hulls.Values)
+            {
+                if (sh.physShapeInfo.ReferenceSame(pShape))
+                {
+                    foundDesc = sh;
+                    ret = true;
+                    break;
+                }
+
+            }
+        }
+        outHull = foundDesc;
+        return ret;
+    }
 }
 
+// ============================================================================================================
 public class BSShapeCompound : BSShape
 {
     private static string LogHeader = "[BULLETSIM SHAPE COMPOUND]";
-    public BSShapeCompound() : base()
+    public static Dictionary<string, BSShapeCompound> CompoundShapes = new Dictionary<string, BSShapeCompound>();
+
+    public BSShapeCompound(BulletShape pShape) : base(pShape)
     {
     }
-    public static BSShape GetReference(BSPhysObject prim) 
-    { 
-        return new BSShapeNull();
+    public static BSShape GetReference(BSScene physicsScene)
+    {
+        // Base compound shapes are not shared so this returns a raw shape.
+        // A built compound shape can be reused in linksets.
+        BSShapeCompound ret = new BSShapeCompound(CreatePhysicalCompoundShape(physicsScene));
+        CompoundShapes.Add(ret.AddrString, ret);
+        return ret;
+    }
+    public override BSShape GetReference(BSScene physicsScene, BSPhysObject prim)
+    {
+        // Calling this reference means we want another handle to an existing compound shape
+        //     (usually linksets) so return this copy.
+        IncrementReference();
+        return this;
+    }
+    // Dereferencing a compound shape releases the hold on all the child shapes.
+    public override void Dereference(BSScene physicsScene)
+    {
+        lock (physShapeInfo)
+        {
+            this.DecrementReference();
+            physicsScene.DetailLog("{0},BSShapeCompound.Dereference,shape={1}", BSScene.DetailLogZero, this);
+            if (referenceCount <= 0)
+            {
+                if (!physicsScene.PE.IsCompound(physShapeInfo))
+                {
+                    // Failed the sanity check!!
+                    physicsScene.Logger.ErrorFormat("{0} Attempt to free a compound shape that is not compound!! type={1}, ptr={2}",
+                                                LogHeader, physShapeInfo.shapeType, physShapeInfo.AddrString);
+                    physicsScene.DetailLog("{0},BSShapeCollection.DereferenceCompound,notACompoundShape,type={1},ptr={2}",
+                                                BSScene.DetailLogZero, physShapeInfo.shapeType, physShapeInfo.AddrString);
+                    return;
+                }
+
+                int numChildren = physicsScene.PE.GetNumberOfCompoundChildren(physShapeInfo);
+                physicsScene.DetailLog("{0},BSShapeCollection.DereferenceCompound,shape={1},children={2}",
+                                        BSScene.DetailLogZero, physShapeInfo, numChildren);
+
+                // Loop through all the children dereferencing each.
+                for (int ii = numChildren - 1; ii >= 0; ii--)
+                {
+                    BulletShape childShape = physicsScene.PE.RemoveChildShapeFromCompoundShapeIndex(physShapeInfo, ii);
+                    DereferenceAnonCollisionShape(physicsScene, childShape);
+                }
+
+                lock (CompoundShapes)
+                    CompoundShapes.Remove(physShapeInfo.AddrString);
+                physicsScene.PE.DeleteCollisionShape(physicsScene.World, physShapeInfo);
+            }
+        }
+    }
+    public static bool TryGetCompoundByPtr(BulletShape pShape, out BSShapeCompound outCompound)
+    {
+        lock (CompoundShapes)
+        {
+            string addr = pShape.AddrString;
+            return CompoundShapes.TryGetValue(addr, out outCompound);
+        }
+    }
+    private static BulletShape CreatePhysicalCompoundShape(BSScene physicsScene)
+    {
+        BulletShape cShape = physicsScene.PE.CreateCompoundShape(physicsScene.World, false);
+        return cShape;
+    }
+    // Sometimes we have a pointer to a collision shape but don't know what type it is.
+    // Figure out type and call the correct dereference routine.
+    // Called at taint-time.
+    private void DereferenceAnonCollisionShape(BSScene physicsScene, BulletShape pShape)
+    {
+        // TODO: figure a better way to go through all the shape types and find a possible instance.
+        physicsScene.DetailLog("{0},BSShapeCompound.DereferenceAnonCollisionShape,shape={1}",
+                                            BSScene.DetailLogZero, pShape);
+        BSShapeMesh meshDesc;
+        if (BSShapeMesh.TryGetMeshByPtr(pShape, out meshDesc))
+        {
+            meshDesc.Dereference(physicsScene);
+            // physicsScene.DetailLog("{0},BSShapeCompound.DereferenceAnonCollisionShape,foundMesh,shape={1}", BSScene.DetailLogZero, pShape);
+        }
+        else
+        {
+            BSShapeHull hullDesc;
+            if (BSShapeHull.TryGetHullByPtr(pShape, out hullDesc))
+            {
+                hullDesc.Dereference(physicsScene);
+                // physicsScene.DetailLog("{0},BSShapeCompound.DereferenceAnonCollisionShape,foundHull,shape={1}", BSScene.DetailLogZero, pShape);
+            }
+            else
+            {
+                BSShapeConvexHull chullDesc;
+                if (BSShapeConvexHull.TryGetConvexHullByPtr(pShape, out chullDesc))
+                {
+                    chullDesc.Dereference(physicsScene);
+                    // physicsScene.DetailLog("{0},BSShapeCompound.DereferenceAnonCollisionShape,foundConvexHull,shape={1}", BSScene.DetailLogZero, pShape);
+                }
+                else
+                {
+                    BSShapeGImpact gImpactDesc;
+                    if (BSShapeGImpact.TryGetGImpactByPtr(pShape, out gImpactDesc))
+                    {
+                        gImpactDesc.Dereference(physicsScene);
+                        // physicsScene.DetailLog("{0},BSShapeCompound.DereferenceAnonCollisionShape,foundgImpact,shape={1}", BSScene.DetailLogZero, pShape);
+                    }
+                    else
+                    {
+                        // Didn't find it in the lists of specific types. It could be compound.
+                        BSShapeCompound compoundDesc;
+                        if (BSShapeCompound.TryGetCompoundByPtr(pShape, out compoundDesc))
+                        {
+                            compoundDesc.Dereference(physicsScene);
+                            // physicsScene.DetailLog("{0},BSShapeCompound.DereferenceAnonCollisionShape,recursiveCompoundShape,shape={1}", BSScene.DetailLogZero, pShape);
+                        }
+                        else
+                        {
+                            // If none of the above, maybe it is a simple native shape.
+                            if (physicsScene.PE.IsNativeShape(pShape))
+                            {
+                                // physicsScene.DetailLog("{0},BSShapeCompound.DereferenceAnonCollisionShape,assumingNative,shape={1}", BSScene.DetailLogZero, pShape);
+                                BSShapeNative nativeShape = new BSShapeNative(pShape);
+                                nativeShape.Dereference(physicsScene);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
+
+// ============================================================================================================
+public class BSShapeConvexHull : BSShape
+{
+    private static string LogHeader = "[BULLETSIM SHAPE CONVEX HULL]";
+    public static Dictionary<System.UInt64, BSShapeConvexHull> ConvexHulls = new Dictionary<System.UInt64, BSShapeConvexHull>();
+
+    public BSShapeConvexHull(BulletShape pShape) : base(pShape)
+    {
+    }
+    public static BSShape GetReference(BSScene physicsScene, bool forceRebuild, BSPhysObject prim)
+    {
+        float lod;
+        System.UInt64 newMeshKey = BSShape.ComputeShapeKey(prim.Size, prim.BaseShape, out lod);
+
+        physicsScene.DetailLog("{0},BSShapeConvexHull,getReference,newKey={1},size={2},lod={3}",
+                                prim.LocalID, newMeshKey.ToString("X"), prim.Size, lod);
+
+        BSShapeConvexHull retConvexHull = null;
+        lock (ConvexHulls)
+        {
+            if (ConvexHulls.TryGetValue(newMeshKey, out retConvexHull))
+            {
+                // The mesh has already been created. Return a new reference to same.
+                retConvexHull.IncrementReference();
+            }
+            else
+            {
+                retConvexHull = new BSShapeConvexHull(new BulletShape());
+                BulletShape convexShape = null;
+
+                // Get a handle to a mesh to build the hull from
+                BSShape baseMesh = BSShapeMesh.GetReference(physicsScene, false /* forceRebuild */, prim);
+                if (baseMesh.physShapeInfo.isNativeShape)
+                {
+                    // We get here if the mesh was not creatable. Could be waiting for an asset from the disk.
+                    // In the short term, we return the native shape and a later ForceBodyShapeRebuild should
+                    //     get back to this code with a buildable mesh.
+                    // TODO: not sure the temp native shape is freed when the mesh is rebuilt. When does this get freed?
+                    convexShape = baseMesh.physShapeInfo;
+                }
+                else
+                {
+                    convexShape = physicsScene.PE.BuildConvexHullShapeFromMesh(physicsScene.World, baseMesh.physShapeInfo);
+                    convexShape.shapeKey = newMeshKey;
+                    ConvexHulls.Add(convexShape.shapeKey, retConvexHull);
+                    physicsScene.DetailLog("{0},BSShapeConvexHull.GetReference,addingNewlyCreatedShape,shape={1}",
+                                        BSScene.DetailLogZero, convexShape);
+                }
+
+                // Done with the base mesh
+                baseMesh.Dereference(physicsScene);
+
+                retConvexHull.physShapeInfo = convexShape;
+            }
+        }
+        return retConvexHull;
+    }
+    public override BSShape GetReference(BSScene physicsScene, BSPhysObject prim)
+    {
+        // Calling this reference means we want another handle to an existing shape
+        //     (usually linksets) so return this copy.
+        IncrementReference();
+        return this;
+    }
+    // Dereferencing a compound shape releases the hold on all the child shapes.
+    public override void Dereference(BSScene physicsScene)
+    {
+        lock (ConvexHulls)
+        {
+            this.DecrementReference();
+            physicsScene.DetailLog("{0},BSShapeConvexHull.Dereference,shape={1}", BSScene.DetailLogZero, this);
+            // TODO: schedule aging and destruction of unused meshes.
+        }
+    }
+    // Loop through all the known hulls and return the description based on the physical address.
+    public static bool TryGetConvexHullByPtr(BulletShape pShape, out BSShapeConvexHull outHull)
+    {
+        bool ret = false;
+        BSShapeConvexHull foundDesc = null;
+        lock (ConvexHulls)
+        {
+            foreach (BSShapeConvexHull sh in ConvexHulls.Values)
+            {
+                if (sh.physShapeInfo.ReferenceSame(pShape))
+                {
+                    foundDesc = sh;
+                    ret = true;
+                    break;
+                }
+
+            }
+        }
+        outHull = foundDesc;
+        return ret;
+    }
+}
+// ============================================================================================================
+public class BSShapeGImpact : BSShape
+{
+    private static string LogHeader = "[BULLETSIM SHAPE GIMPACT]";
+    public static Dictionary<System.UInt64, BSShapeGImpact> GImpacts = new Dictionary<System.UInt64, BSShapeGImpact>();
+
+    public BSShapeGImpact(BulletShape pShape) : base(pShape)
+    {
+    }
+    public static BSShape GetReference(BSScene physicsScene, bool forceRebuild, BSPhysObject prim)
+    {
+        float lod;
+        System.UInt64 newMeshKey = BSShape.ComputeShapeKey(prim.Size, prim.BaseShape, out lod);
+
+        physicsScene.DetailLog("{0},BSShapeGImpact,getReference,newKey={1},size={2},lod={3}",
+                                prim.LocalID, newMeshKey.ToString("X"), prim.Size, lod);
+
+        BSShapeGImpact retGImpact = null;
+        lock (GImpacts)
+        {
+            if (GImpacts.TryGetValue(newMeshKey, out retGImpact))
+            {
+                // The mesh has already been created. Return a new reference to same.
+                retGImpact.IncrementReference();
+            }
+            else
+            {
+                retGImpact = new BSShapeGImpact(new BulletShape());
+                BulletShape newShape = retGImpact.CreatePhysicalGImpact(physicsScene, prim, newMeshKey, prim.BaseShape, prim.Size, lod);
+
+                // Check to see if mesh was created (might require an asset).
+                newShape = VerifyMeshCreated(physicsScene, newShape, prim);
+                newShape.shapeKey = newMeshKey;
+                if (!newShape.isNativeShape 
+                            || prim.PrimAssetState == BSPhysObject.PrimAssetCondition.FailedMeshing
+                            || prim.PrimAssetState == BSPhysObject.PrimAssetCondition.FailedAssetFetch)
+                {
+                    // If a mesh was what was created, remember the built shape for later sharing.
+                    // Also note that if meshing failed we put it in the mesh list as there is nothing
+                    //         else to do about the mesh.
+                    GImpacts.Add(newMeshKey, retGImpact);
+                }
+
+                retGImpact.physShapeInfo = newShape;
+            }
+        }
+        return retGImpact;
+    }
+
+    private BulletShape CreatePhysicalGImpact(BSScene physicsScene, BSPhysObject prim, System.UInt64 newMeshKey,
+                                            PrimitiveBaseShape pbs, OMV.Vector3 size, float lod)
+    {
+        return BSShapeMesh.CreatePhysicalMeshShape(physicsScene, prim, newMeshKey, pbs, size, lod,
+                            (w, iC, i, vC, v) => physicsScene.PE.CreateGImpactShape(w, iC, i, vC, v) );
+    }
+
+    public override BSShape GetReference(BSScene pPhysicsScene, BSPhysObject pPrim)
+    {
+        BSShape ret = null;
+        // If the underlying shape is native, the actual shape has not been build (waiting for asset)
+        //     and we must create a copy of the native shape since they are never shared.
+        if (physShapeInfo.HasPhysicalShape && physShapeInfo.isNativeShape)
+        {
+            // TODO: decide when the native shapes should be freed. Check in Dereference?
+            ret = BSShapeNative.GetReference(pPhysicsScene, pPrim, BSPhysicsShapeType.SHAPE_BOX, FixedShapeKey.KEY_BOX);
+        }
+        else
+        {
+            // Another reference to this shape is just counted.
+            IncrementReference();
+            ret = this;
+        }
+        return ret;
+    }
+    // Dereferencing a compound shape releases the hold on all the child shapes.
+    public override void Dereference(BSScene physicsScene)
+    {
+        lock (GImpacts)
+        {
+            this.DecrementReference();
+            physicsScene.DetailLog("{0},BSShapeGImpact.Dereference,shape={1}", BSScene.DetailLogZero, this);
+            // TODO: schedule aging and destruction of unused meshes.
+        }
+    }
+    // Loop through all the known hulls and return the description based on the physical address.
+    public static bool TryGetGImpactByPtr(BulletShape pShape, out BSShapeGImpact outHull)
+    {
+        bool ret = false;
+        BSShapeGImpact foundDesc = null;
+        lock (GImpacts)
+        {
+            foreach (BSShapeGImpact sh in GImpacts.Values)
+            {
+                if (sh.physShapeInfo.ReferenceSame(pShape))
+                {
+                    foundDesc = sh;
+                    ret = true;
+                    break;
+                }
+
+            }
+        }
+        outHull = foundDesc;
+        return ret;
     }
-    public override void Dereference(BSScene physicsScene) { }
 }
 
+// ============================================================================================================
 public class BSShapeAvatar : BSShape
 {
     private static string LogHeader = "[BULLETSIM SHAPE AVATAR]";
     public BSShapeAvatar() : base()
     {
     }
-    public static BSShape GetReference(BSPhysObject prim) 
-    { 
+    public static BSShape GetReference(BSPhysObject prim)
+    {
+        return new BSShapeNull();
+    }
+    public override BSShape GetReference(BSScene pPhysicsScene, BSPhysObject pPrim)
+    {
         return new BSShapeNull();
     }
     public override void Dereference(BSScene physicsScene) { }
diff --git a/OpenSim/Region/Physics/BulletSPlugin/BSTerrainHeightmap.cs b/OpenSim/Region/Physics/BulletSPlugin/BSTerrainHeightmap.cs
index e4fecc3..8888d6d 100755
--- a/OpenSim/Region/Physics/BulletSPlugin/BSTerrainHeightmap.cs
+++ b/OpenSim/Region/Physics/BulletSPlugin/BSTerrainHeightmap.cs
@@ -68,7 +68,7 @@ public sealed class BSTerrainHeightmap : BSTerrainPhys
 
     // This minCoords and maxCoords passed in give the size of the terrain (min and max Z
     //         are the high and low points of the heightmap).
-    public BSTerrainHeightmap(BSScene physicsScene, Vector3 regionBase, uint id, float[] initialMap, 
+    public BSTerrainHeightmap(BSScene physicsScene, Vector3 regionBase, uint id, float[] initialMap,
                                                     Vector3 minCoords, Vector3 maxCoords)
         : base(physicsScene, regionBase, id)
     {
@@ -92,7 +92,7 @@ public sealed class BSTerrainHeightmap : BSTerrainPhys
     private void BuildHeightmapTerrain()
     {
         // Create the terrain shape from the mapInfo
-        m_mapInfo.terrainShape = PhysicsScene.PE.CreateTerrainShape( m_mapInfo.ID, 
+        m_mapInfo.terrainShape = m_physicsScene.PE.CreateTerrainShape( m_mapInfo.ID,
                                 new Vector3(m_mapInfo.sizeX, m_mapInfo.sizeY, 0), m_mapInfo.minZ, m_mapInfo.maxZ,
                                 m_mapInfo.heightMap, 1f, BSParam.TerrainCollisionMargin);
 
@@ -103,26 +103,25 @@ public sealed class BSTerrainHeightmap : BSTerrainPhys
         centerPos.Y = m_mapInfo.minCoords.Y + (m_mapInfo.sizeY / 2f);
         centerPos.Z = m_mapInfo.minZ + ((m_mapInfo.maxZ - m_mapInfo.minZ) / 2f);
 
-        m_mapInfo.terrainBody = PhysicsScene.PE.CreateBodyWithDefaultMotionState(m_mapInfo.terrainShape, 
+        m_mapInfo.terrainBody = m_physicsScene.PE.CreateBodyWithDefaultMotionState(m_mapInfo.terrainShape,
                                 m_mapInfo.ID, centerPos, Quaternion.Identity);
 
         // Set current terrain attributes
-        PhysicsScene.PE.SetFriction(m_mapInfo.terrainBody, BSParam.TerrainFriction);
-        PhysicsScene.PE.SetHitFraction(m_mapInfo.terrainBody, BSParam.TerrainHitFraction);
-        PhysicsScene.PE.SetRestitution(m_mapInfo.terrainBody, BSParam.TerrainRestitution);
-        PhysicsScene.PE.SetCollisionFlags(m_mapInfo.terrainBody, CollisionFlags.CF_STATIC_OBJECT);
+        m_physicsScene.PE.SetFriction(m_mapInfo.terrainBody, BSParam.TerrainFriction);
+        m_physicsScene.PE.SetHitFraction(m_mapInfo.terrainBody, BSParam.TerrainHitFraction);
+        m_physicsScene.PE.SetRestitution(m_mapInfo.terrainBody, BSParam.TerrainRestitution);
+        m_physicsScene.PE.SetCollisionFlags(m_mapInfo.terrainBody, CollisionFlags.CF_STATIC_OBJECT);
+
+        m_mapInfo.terrainBody.collisionType = CollisionType.Terrain;
 
         // Return the new terrain to the world of physical objects
-        PhysicsScene.PE.AddObjectToWorld(PhysicsScene.World, m_mapInfo.terrainBody);
+        m_physicsScene.PE.AddObjectToWorld(m_physicsScene.World, m_mapInfo.terrainBody);
 
         // redo its bounding box now that it is in the world
-        PhysicsScene.PE.UpdateSingleAabb(PhysicsScene.World, m_mapInfo.terrainBody);
-
-        m_mapInfo.terrainBody.collisionType = CollisionType.Terrain;
-        m_mapInfo.terrainBody.ApplyCollisionMask(PhysicsScene);
+        m_physicsScene.PE.UpdateSingleAabb(m_physicsScene.World, m_mapInfo.terrainBody);
 
         // Make it so the terrain will not move or be considered for movement.
-        PhysicsScene.PE.ForceActivationState(m_mapInfo.terrainBody, ActivationState.DISABLE_SIMULATION);
+        m_physicsScene.PE.ForceActivationState(m_mapInfo.terrainBody, ActivationState.DISABLE_SIMULATION);
 
         return;
     }
@@ -134,9 +133,9 @@ public sealed class BSTerrainHeightmap : BSTerrainPhys
         {
             if (m_mapInfo.terrainBody.HasPhysicalBody)
             {
-                PhysicsScene.PE.RemoveObjectFromWorld(PhysicsScene.World, m_mapInfo.terrainBody);
+                m_physicsScene.PE.RemoveObjectFromWorld(m_physicsScene.World, m_mapInfo.terrainBody);
                 // Frees both the body and the shape.
-                PhysicsScene.PE.DestroyObject(PhysicsScene.World, m_mapInfo.terrainBody);
+                m_physicsScene.PE.DestroyObject(m_physicsScene.World, m_mapInfo.terrainBody);
             }
         }
         m_mapInfo = null;
@@ -155,7 +154,7 @@ public sealed class BSTerrainHeightmap : BSTerrainPhys
         catch
         {
             // Sometimes they give us wonky values of X and Y. Give a warning and return something.
-            PhysicsScene.Logger.WarnFormat("{0} Bad request for terrain height. terrainBase={1}, pos={2}",
+            m_physicsScene.Logger.WarnFormat("{0} Bad request for terrain height. terrainBase={1}, pos={2}",
                                 LogHeader, m_mapInfo.terrainRegionBase, pos);
             ret = BSTerrainManager.HEIGHT_GETHEIGHT_RET;
         }
@@ -165,7 +164,7 @@ public sealed class BSTerrainHeightmap : BSTerrainPhys
     // The passed position is relative to the base of the region.
     public override float GetWaterLevelAtXYZ(Vector3 pos)
     {
-        return PhysicsScene.SimpleWaterLevel;
+        return m_physicsScene.SimpleWaterLevel;
     }
 }
 }
diff --git a/OpenSim/Region/Physics/BulletSPlugin/BSTerrainManager.cs b/OpenSim/Region/Physics/BulletSPlugin/BSTerrainManager.cs
index b2fb835..441d2d3 100755
--- a/OpenSim/Region/Physics/BulletSPlugin/BSTerrainManager.cs
+++ b/OpenSim/Region/Physics/BulletSPlugin/BSTerrainManager.cs
@@ -50,14 +50,14 @@ public abstract class BSTerrainPhys : IDisposable
         Mesh        = 1
     }
 
-    public BSScene PhysicsScene { get; private set; }
+    protected BSScene m_physicsScene { get; private set; }
     // Base of the region in world coordinates. Coordinates inside the region are relative to this.
     public Vector3 TerrainBase { get; private set; }
     public uint ID { get; private set; }
 
     public BSTerrainPhys(BSScene physicsScene, Vector3 regionBase, uint id)
     {
-        PhysicsScene = physicsScene;
+        m_physicsScene = physicsScene;
         TerrainBase = regionBase;
         ID = id;
     }
@@ -86,7 +86,7 @@ public sealed class BSTerrainManager : IDisposable
     public Vector3 DefaultRegionSize = new Vector3(Constants.RegionSize, Constants.RegionSize, Constants.RegionHeight);
 
     // The scene that I am part of
-    private BSScene PhysicsScene { get; set; }
+    private BSScene m_physicsScene { get; set; }
 
     // The ground plane created to keep thing from falling to infinity.
     private BulletBody m_groundPlane;
@@ -113,7 +113,7 @@ public sealed class BSTerrainManager : IDisposable
 
     public BSTerrainManager(BSScene physicsScene)
     {
-        PhysicsScene = physicsScene;
+        m_physicsScene = physicsScene;
         m_terrains = new Dictionary<Vector3,BSTerrainPhys>();
 
         // Assume one region of default size
@@ -132,21 +132,22 @@ public sealed class BSTerrainManager : IDisposable
     //    safe to call Bullet in real time. We hope no one is moving prims around yet.
     public void CreateInitialGroundPlaneAndTerrain()
     {
-        DetailLog("{0},BSTerrainManager.CreateInitialGroundPlaneAndTerrain,region={1}", BSScene.DetailLogZero, PhysicsScene.RegionName);
+        DetailLog("{0},BSTerrainManager.CreateInitialGroundPlaneAndTerrain,region={1}", BSScene.DetailLogZero, m_physicsScene.RegionName);
         // The ground plane is here to catch things that are trying to drop to negative infinity
-        BulletShape groundPlaneShape = PhysicsScene.PE.CreateGroundPlaneShape(BSScene.GROUNDPLANE_ID, 1f, BSParam.TerrainCollisionMargin);
-        m_groundPlane = PhysicsScene.PE.CreateBodyWithDefaultMotionState(groundPlaneShape, 
+        BulletShape groundPlaneShape = m_physicsScene.PE.CreateGroundPlaneShape(BSScene.GROUNDPLANE_ID, 1f, BSParam.TerrainCollisionMargin);
+        m_groundPlane = m_physicsScene.PE.CreateBodyWithDefaultMotionState(groundPlaneShape,
                                         BSScene.GROUNDPLANE_ID, Vector3.Zero, Quaternion.Identity);
 
-        PhysicsScene.PE.AddObjectToWorld(PhysicsScene.World, m_groundPlane);
-        PhysicsScene.PE.UpdateSingleAabb(PhysicsScene.World, m_groundPlane);
-        // Ground plane does not move
-        PhysicsScene.PE.ForceActivationState(m_groundPlane, ActivationState.DISABLE_SIMULATION);
         // Everything collides with the ground plane.
         m_groundPlane.collisionType = CollisionType.Groundplane;
-        m_groundPlane.ApplyCollisionMask(PhysicsScene);
 
-        BSTerrainPhys initialTerrain = new BSTerrainHeightmap(PhysicsScene, Vector3.Zero, BSScene.TERRAIN_ID, DefaultRegionSize);
+        m_physicsScene.PE.AddObjectToWorld(m_physicsScene.World, m_groundPlane);
+        m_physicsScene.PE.UpdateSingleAabb(m_physicsScene.World, m_groundPlane);
+
+        // Ground plane does not move
+        m_physicsScene.PE.ForceActivationState(m_groundPlane, ActivationState.DISABLE_SIMULATION);
+
+        BSTerrainPhys initialTerrain = new BSTerrainHeightmap(m_physicsScene, Vector3.Zero, BSScene.TERRAIN_ID, DefaultRegionSize);
         lock (m_terrains)
         {
             // Build an initial terrain and put it in the world. This quickly gets replaced by the real region terrain.
@@ -157,12 +158,12 @@ public sealed class BSTerrainManager : IDisposable
     // Release all the terrain structures we might have allocated
     public void ReleaseGroundPlaneAndTerrain()
     {
-        DetailLog("{0},BSTerrainManager.ReleaseGroundPlaneAndTerrain,region={1}", BSScene.DetailLogZero, PhysicsScene.RegionName);
+        DetailLog("{0},BSTerrainManager.ReleaseGroundPlaneAndTerrain,region={1}", BSScene.DetailLogZero, m_physicsScene.RegionName);
         if (m_groundPlane.HasPhysicalBody)
         {
-            if (PhysicsScene.PE.RemoveObjectFromWorld(PhysicsScene.World, m_groundPlane))
+            if (m_physicsScene.PE.RemoveObjectFromWorld(m_physicsScene.World, m_groundPlane))
             {
-                PhysicsScene.PE.DestroyObject(PhysicsScene.World, m_groundPlane);
+                m_physicsScene.PE.DestroyObject(m_physicsScene.World, m_groundPlane);
             }
             m_groundPlane.Clear();
         }
@@ -188,7 +189,7 @@ public sealed class BSTerrainManager : IDisposable
         float[] localHeightMap = heightMap;
         // If there are multiple requests for changes to the same terrain between ticks,
         //      only do that last one.
-        PhysicsScene.PostTaintObject("TerrainManager.SetTerrain-"+ m_worldOffset.ToString(), 0, delegate()
+        m_physicsScene.PostTaintObject("TerrainManager.SetTerrain-"+ m_worldOffset.ToString(), 0, delegate()
         {
             if (m_worldOffset != Vector3.Zero && MegaRegionParentPhysicsScene != null)
             {
@@ -199,15 +200,8 @@ public sealed class BSTerrainManager : IDisposable
                 if (MegaRegionParentPhysicsScene is BSScene)
                 {
                     DetailLog("{0},SetTerrain.ToParent,offset={1},worldMax={2}", BSScene.DetailLogZero, m_worldOffset, m_worldMax);
-                    // This looks really odd but this region is passing its terrain to its mega-region root region
-                    //    and the creation of the terrain must happen on the root region's taint thread and not
-                    //    my taint thread.
-                    ((BSScene)MegaRegionParentPhysicsScene).PostTaintObject("TerrainManager.SetTerrain.Mega-" + m_worldOffset.ToString(), 0, delegate()
-                    {
-                        ((BSScene)MegaRegionParentPhysicsScene).TerrainManager.UpdateTerrain(
-                                        BSScene.CHILDTERRAIN_ID, localHeightMap,
-                                        m_worldOffset, m_worldOffset + DefaultRegionSize, true /* inTaintTime */);
-                    });
+                    ((BSScene)MegaRegionParentPhysicsScene).TerrainManager.AddMegaRegionChildTerrain(
+                                        BSScene.CHILDTERRAIN_ID, localHeightMap, m_worldOffset, m_worldOffset + DefaultRegionSize);
                 }
             }
             else
@@ -215,12 +209,23 @@ public sealed class BSTerrainManager : IDisposable
                 // If not doing the mega-prim thing, just change the terrain
                 DetailLog("{0},SetTerrain.Existing", BSScene.DetailLogZero);
 
-                UpdateTerrain(BSScene.TERRAIN_ID, localHeightMap,
-                                    m_worldOffset, m_worldOffset + DefaultRegionSize, true /* inTaintTime */);
+                UpdateTerrain(BSScene.TERRAIN_ID, localHeightMap, m_worldOffset, m_worldOffset + DefaultRegionSize);
             }
         });
     }
 
+    // Another region is calling this region and passing a terrain.
+    // A region that is not the mega-region root will pass its terrain to the root region so the root region
+    //      physics engine will have all the terrains.
+    private void AddMegaRegionChildTerrain(uint id, float[] heightMap, Vector3 minCoords, Vector3 maxCoords)
+    {
+        // Since we are called by another region's thread, the action must be rescheduled onto our processing thread.
+        m_physicsScene.PostTaintObject("TerrainManager.AddMegaRegionChild" + minCoords.ToString(), id, delegate()
+        {
+            UpdateTerrain(id, heightMap, minCoords, maxCoords);
+        });
+    }
+
     // If called for terrain has has not been previously allocated, a new terrain will be built
     //     based on the passed information. The 'id' should be either the terrain id or
     //     BSScene.CHILDTERRAIN_ID. If the latter, a new child terrain ID will be allocated and used.
@@ -230,11 +235,10 @@ public sealed class BSTerrainManager : IDisposable
     //     This call is most often used to update the heightMap and parameters of the terrain.
     // (The above does suggest that some simplification/refactoring is in order.)
     // Called during taint-time.
-    private void UpdateTerrain(uint id, float[] heightMap, 
-                            Vector3 minCoords, Vector3 maxCoords, bool inTaintTime)
+    private void UpdateTerrain(uint id, float[] heightMap, Vector3 minCoords, Vector3 maxCoords)
     {
-        DetailLog("{0},BSTerrainManager.UpdateTerrain,call,id={1},minC={2},maxC={3},inTaintTime={4}",
-                            BSScene.DetailLogZero, id, minCoords, maxCoords, inTaintTime);
+        DetailLog("{0},BSTerrainManager.UpdateTerrain,call,id={1},minC={2},maxC={3}",
+                            BSScene.DetailLogZero, id, minCoords, maxCoords);
 
         // Find high and low points of passed heightmap.
         // The min and max passed in is usually the area objects can be in (maximum
@@ -303,7 +307,7 @@ public sealed class BSTerrainManager : IDisposable
                     newTerrainID = ++m_terrainCount;
 
                 DetailLog("{0},BSTerrainManager.UpdateTerrain:NewTerrain,taint,newID={1},minCoord={2},maxCoord={3}",
-                                            BSScene.DetailLogZero, newTerrainID, minCoords, minCoords);
+                                            BSScene.DetailLogZero, newTerrainID, minCoords, maxCoords);
                 BSTerrainPhys newTerrainPhys = BuildPhysicalTerrain(terrainRegionBase, id, heightMap, minCoords, maxCoords);
                 m_terrains.Add(terrainRegionBase, newTerrainPhys);
 
@@ -315,26 +319,26 @@ public sealed class BSTerrainManager : IDisposable
     // TODO: redo terrain implementation selection to allow other base types than heightMap.
     private BSTerrainPhys BuildPhysicalTerrain(Vector3 terrainRegionBase, uint id, float[] heightMap, Vector3 minCoords, Vector3 maxCoords)
     {
-        PhysicsScene.Logger.DebugFormat("{0} Terrain for {1}/{2} created with {3}", 
-                                            LogHeader, PhysicsScene.RegionName, terrainRegionBase, 
+        m_physicsScene.Logger.DebugFormat("{0} Terrain for {1}/{2} created with {3}",
+                                            LogHeader, m_physicsScene.RegionName, terrainRegionBase,
                                             (BSTerrainPhys.TerrainImplementation)BSParam.TerrainImplementation);
         BSTerrainPhys newTerrainPhys = null;
         switch ((int)BSParam.TerrainImplementation)
         {
             case (int)BSTerrainPhys.TerrainImplementation.Heightmap:
-                newTerrainPhys = new BSTerrainHeightmap(PhysicsScene, terrainRegionBase, id,
+                newTerrainPhys = new BSTerrainHeightmap(m_physicsScene, terrainRegionBase, id,
                                             heightMap, minCoords, maxCoords);
                 break;
             case (int)BSTerrainPhys.TerrainImplementation.Mesh:
-                newTerrainPhys = new BSTerrainMesh(PhysicsScene, terrainRegionBase, id,
+                newTerrainPhys = new BSTerrainMesh(m_physicsScene, terrainRegionBase, id,
                                             heightMap, minCoords, maxCoords);
                 break;
             default:
-                PhysicsScene.Logger.ErrorFormat("{0} Bad terrain implementation specified. Type={1}/{2},Region={3}/{4}",
-                                            LogHeader, 
-                                            (int)BSParam.TerrainImplementation, 
+                m_physicsScene.Logger.ErrorFormat("{0} Bad terrain implementation specified. Type={1}/{2},Region={3}/{4}",
+                                            LogHeader,
+                                            (int)BSParam.TerrainImplementation,
                                             BSParam.TerrainImplementation,
-                                            PhysicsScene.RegionName, terrainRegionBase);
+                                            m_physicsScene.RegionName, terrainRegionBase);
                 break;
         }
         return newTerrainPhys;
@@ -351,6 +355,8 @@ public sealed class BSTerrainManager : IDisposable
     // Return a new position that is over known terrain if the position is outside our terrain.
     public Vector3 ClampPositionIntoKnownTerrain(Vector3 pPos)
     {
+        float edgeEpsilon = 0.1f;
+
         Vector3 ret = pPos;
 
         // First, base addresses are never negative so correct for that possible problem.
@@ -375,10 +381,19 @@ public sealed class BSTerrainManager : IDisposable
             // NOTE that GetTerrainPhysicalAtXYZ will set 'terrainBaseXYZ' to the base of the unfound region.
 
             // Must be off the top of a region. Find an adjacent region to move into.
+            //     The returned terrain is always 'lower'. That is, closer to <0,0>.
             Vector3 adjacentTerrainBase = FindAdjacentTerrainBase(terrainBaseXYZ);
 
-            ret.X = Math.Min(ret.X, adjacentTerrainBase.X + (ret.X % DefaultRegionSize.X));
-            ret.Y = Math.Min(ret.Y, adjacentTerrainBase.Y + (ret.X % DefaultRegionSize.Y));
+            if (adjacentTerrainBase.X < terrainBaseXYZ.X)
+            {
+                // moving down into a new region in the X dimension. New position will be the max in the new base.
+                ret.X = adjacentTerrainBase.X + DefaultRegionSize.X - edgeEpsilon;
+            }
+            if (adjacentTerrainBase.Y < terrainBaseXYZ.Y)
+            {
+                // moving down into a new region in the X dimension. New position will be the max in the new base.
+                ret.Y = adjacentTerrainBase.Y + DefaultRegionSize.Y - edgeEpsilon;
+            }
             DetailLog("{0},BSTerrainManager.ClampPositionToKnownTerrain,findingAdjacentRegion,adjacentRegBase={1},oldPos={2},newPos={3}",
                                         BSScene.DetailLogZero, adjacentTerrainBase, pPos, ret);
 
@@ -426,8 +441,8 @@ public sealed class BSTerrainManager : IDisposable
         }
         else
         {
-            PhysicsScene.Logger.ErrorFormat("{0} GetTerrainHeightAtXY: terrain not found: region={1}, x={2}, y={3}",
-                    LogHeader, PhysicsScene.RegionName, tX, tY);
+            m_physicsScene.Logger.ErrorFormat("{0} GetTerrainHeightAtXY: terrain not found: region={1}, x={2}, y={3}",
+                    LogHeader, m_physicsScene.RegionName, tX, tY);
             DetailLog("{0},BSTerrainManager.GetTerrainHeightAtXYZ,terrainNotFound,pos={1},base={2}",
                                 BSScene.DetailLogZero, pos, terrainBaseXYZ);
         }
@@ -448,8 +463,8 @@ public sealed class BSTerrainManager : IDisposable
         }
         else
         {
-            PhysicsScene.Logger.ErrorFormat("{0} GetWaterHeightAtXY: terrain not found: pos={1}, terrainBase={2}, height={3}",
-                    LogHeader, PhysicsScene.RegionName, pos, terrainBaseXYZ, ret);
+            m_physicsScene.Logger.ErrorFormat("{0} GetWaterHeightAtXY: terrain not found: pos={1}, terrainBase={2}, height={3}",
+                    LogHeader, m_physicsScene.RegionName, pos, terrainBaseXYZ, ret);
         }
         return ret;
     }
@@ -561,7 +576,7 @@ public sealed class BSTerrainManager : IDisposable
 
     private void DetailLog(string msg, params Object[] args)
     {
-        PhysicsScene.PhysicsLogging.Write(msg, args);
+        m_physicsScene.PhysicsLogging.Write(msg, args);
     }
 }
 }
diff --git a/OpenSim/Region/Physics/BulletSPlugin/BSTerrainMesh.cs b/OpenSim/Region/Physics/BulletSPlugin/BSTerrainMesh.cs
index 2ce1513..e4ca098 100755
--- a/OpenSim/Region/Physics/BulletSPlugin/BSTerrainMesh.cs
+++ b/OpenSim/Region/Physics/BulletSPlugin/BSTerrainMesh.cs
@@ -51,7 +51,7 @@ public sealed class BSTerrainMesh : BSTerrainPhys
     BulletShape m_terrainShape;
     BulletBody m_terrainBody;
 
-    public BSTerrainMesh(BSScene physicsScene, Vector3 regionBase, uint id, Vector3 regionSize) 
+    public BSTerrainMesh(BSScene physicsScene, Vector3 regionBase, uint id, Vector3 regionSize)
         : base(physicsScene, regionBase, id)
     {
     }
@@ -62,7 +62,7 @@ public sealed class BSTerrainMesh : BSTerrainPhys
     }
 
     // Create terrain mesh from a heightmap.
-    public BSTerrainMesh(BSScene physicsScene, Vector3 regionBase, uint id, float[] initialMap, 
+    public BSTerrainMesh(BSScene physicsScene, Vector3 regionBase, uint id, float[] initialMap,
                                                     Vector3 minCoords, Vector3 maxCoords)
         : base(physicsScene, regionBase, id)
     {
@@ -80,7 +80,7 @@ public sealed class BSTerrainMesh : BSTerrainPhys
         if (BSParam.TerrainMeshMagnification == 1)
         {
             // If a magnification of one, use the old routine that is tried and true.
-            meshCreationSuccess = BSTerrainMesh.ConvertHeightmapToMesh(PhysicsScene,
+            meshCreationSuccess = BSTerrainMesh.ConvertHeightmapToMesh(m_physicsScene,
                                             initialMap, m_sizeX, m_sizeY,       // input size
                                             Vector3.Zero,                       // base for mesh
                                             out indicesCount, out indices, out verticesCount, out vertices);
@@ -88,7 +88,7 @@ public sealed class BSTerrainMesh : BSTerrainPhys
         else
         {
             // Other magnifications use the newer routine
-            meshCreationSuccess = BSTerrainMesh.ConvertHeightmapToMesh2(PhysicsScene,
+            meshCreationSuccess = BSTerrainMesh.ConvertHeightmapToMesh2(m_physicsScene,
                                             initialMap, m_sizeX, m_sizeY,       // input size
                                             BSParam.TerrainMeshMagnification,
                                             physicsScene.TerrainManager.DefaultRegionSize,
@@ -98,21 +98,21 @@ public sealed class BSTerrainMesh : BSTerrainPhys
         if (!meshCreationSuccess)
         {
             // DISASTER!!
-            PhysicsScene.DetailLog("{0},BSTerrainMesh.create,failedConversionOfHeightmap,id={1}", BSScene.DetailLogZero, ID);
-            PhysicsScene.Logger.ErrorFormat("{0} Failed conversion of heightmap to mesh! base={1}", LogHeader, TerrainBase);
+            m_physicsScene.DetailLog("{0},BSTerrainMesh.create,failedConversionOfHeightmap,id={1}", BSScene.DetailLogZero, ID);
+            m_physicsScene.Logger.ErrorFormat("{0} Failed conversion of heightmap to mesh! base={1}", LogHeader, TerrainBase);
             // Something is very messed up and a crash is in our future.
             return;
         }
 
-        PhysicsScene.DetailLog("{0},BSTerrainMesh.create,meshed,id={1},indices={2},indSz={3},vertices={4},vertSz={5}", 
+        m_physicsScene.DetailLog("{0},BSTerrainMesh.create,meshed,id={1},indices={2},indSz={3},vertices={4},vertSz={5}",
                                 BSScene.DetailLogZero, ID, indicesCount, indices.Length, verticesCount, vertices.Length);
 
-        m_terrainShape = PhysicsScene.PE.CreateMeshShape(PhysicsScene.World, indicesCount, indices, verticesCount, vertices);
+        m_terrainShape = m_physicsScene.PE.CreateMeshShape(m_physicsScene.World, indicesCount, indices, verticesCount, vertices);
         if (!m_terrainShape.HasPhysicalShape)
         {
             // DISASTER!!
-            PhysicsScene.DetailLog("{0},BSTerrainMesh.create,failedCreationOfShape,id={1}", BSScene.DetailLogZero, ID);
-            PhysicsScene.Logger.ErrorFormat("{0} Failed creation of terrain mesh! base={1}", LogHeader, TerrainBase);
+            m_physicsScene.DetailLog("{0},BSTerrainMesh.create,failedCreationOfShape,id={1}", BSScene.DetailLogZero, ID);
+            m_physicsScene.Logger.ErrorFormat("{0} Failed creation of terrain mesh! base={1}", LogHeader, TerrainBase);
             // Something is very messed up and a crash is in our future.
             return;
         }
@@ -120,52 +120,52 @@ public sealed class BSTerrainMesh : BSTerrainPhys
         Vector3 pos = regionBase;
         Quaternion rot = Quaternion.Identity;
 
-        m_terrainBody = PhysicsScene.PE.CreateBodyWithDefaultMotionState(m_terrainShape, ID, pos, rot);
+        m_terrainBody = m_physicsScene.PE.CreateBodyWithDefaultMotionState(m_terrainShape, ID, pos, rot);
         if (!m_terrainBody.HasPhysicalBody)
         {
             // DISASTER!!
-            PhysicsScene.Logger.ErrorFormat("{0} Failed creation of terrain body! base={1}", LogHeader, TerrainBase);
+            m_physicsScene.Logger.ErrorFormat("{0} Failed creation of terrain body! base={1}", LogHeader, TerrainBase);
             // Something is very messed up and a crash is in our future.
             return;
         }
         physicsScene.PE.SetShapeCollisionMargin(m_terrainShape, BSParam.TerrainCollisionMargin);
 
         // Set current terrain attributes
-        PhysicsScene.PE.SetFriction(m_terrainBody, BSParam.TerrainFriction);
-        PhysicsScene.PE.SetHitFraction(m_terrainBody, BSParam.TerrainHitFraction);
-        PhysicsScene.PE.SetRestitution(m_terrainBody, BSParam.TerrainRestitution);
-        PhysicsScene.PE.SetContactProcessingThreshold(m_terrainBody, BSParam.TerrainContactProcessingThreshold);
-        PhysicsScene.PE.SetCollisionFlags(m_terrainBody, CollisionFlags.CF_STATIC_OBJECT);
+        m_physicsScene.PE.SetFriction(m_terrainBody, BSParam.TerrainFriction);
+        m_physicsScene.PE.SetHitFraction(m_terrainBody, BSParam.TerrainHitFraction);
+        m_physicsScene.PE.SetRestitution(m_terrainBody, BSParam.TerrainRestitution);
+        m_physicsScene.PE.SetContactProcessingThreshold(m_terrainBody, BSParam.TerrainContactProcessingThreshold);
+        m_physicsScene.PE.SetCollisionFlags(m_terrainBody, CollisionFlags.CF_STATIC_OBJECT);
 
         // Static objects are not very massive.
-        PhysicsScene.PE.SetMassProps(m_terrainBody, 0f, Vector3.Zero);
+        m_physicsScene.PE.SetMassProps(m_terrainBody, 0f, Vector3.Zero);
 
         // Put the new terrain to the world of physical objects
-        PhysicsScene.PE.AddObjectToWorld(PhysicsScene.World, m_terrainBody);
+        m_physicsScene.PE.AddObjectToWorld(m_physicsScene.World, m_terrainBody);
 
         // Redo its bounding box now that it is in the world
-        PhysicsScene.PE.UpdateSingleAabb(PhysicsScene.World, m_terrainBody);
+        m_physicsScene.PE.UpdateSingleAabb(m_physicsScene.World, m_terrainBody);
 
         m_terrainBody.collisionType = CollisionType.Terrain;
-        m_terrainBody.ApplyCollisionMask(PhysicsScene);
+        m_terrainBody.ApplyCollisionMask(m_physicsScene);
 
         if (BSParam.UseSingleSidedMeshes)
         {
-            PhysicsScene.DetailLog("{0},BSTerrainMesh.settingCustomMaterial,id={1}", BSScene.DetailLogZero, id);
-            PhysicsScene.PE.AddToCollisionFlags(m_terrainBody, CollisionFlags.CF_CUSTOM_MATERIAL_CALLBACK);
+            m_physicsScene.DetailLog("{0},BSTerrainMesh.settingCustomMaterial,id={1}", BSScene.DetailLogZero, id);
+            m_physicsScene.PE.AddToCollisionFlags(m_terrainBody, CollisionFlags.CF_CUSTOM_MATERIAL_CALLBACK);
         }
 
         // Make it so the terrain will not move or be considered for movement.
-        PhysicsScene.PE.ForceActivationState(m_terrainBody, ActivationState.DISABLE_SIMULATION);
+        m_physicsScene.PE.ForceActivationState(m_terrainBody, ActivationState.DISABLE_SIMULATION);
     }
 
     public override void Dispose()
     {
         if (m_terrainBody.HasPhysicalBody)
         {
-            PhysicsScene.PE.RemoveObjectFromWorld(PhysicsScene.World, m_terrainBody);
+            m_physicsScene.PE.RemoveObjectFromWorld(m_physicsScene.World, m_terrainBody);
             // Frees both the body and the shape.
-            PhysicsScene.PE.DestroyObject(PhysicsScene.World, m_terrainBody);
+            m_physicsScene.PE.DestroyObject(m_physicsScene.World, m_terrainBody);
             m_terrainBody.Clear();
             m_terrainShape.Clear();
         }
@@ -185,7 +185,7 @@ public sealed class BSTerrainMesh : BSTerrainPhys
         catch
         {
             // Sometimes they give us wonky values of X and Y. Give a warning and return something.
-            PhysicsScene.Logger.WarnFormat("{0} Bad request for terrain height. terrainBase={1}, pos={2}",
+            m_physicsScene.Logger.WarnFormat("{0} Bad request for terrain height. terrainBase={1}, pos={2}",
                                                 LogHeader, TerrainBase, pos);
             ret = BSTerrainManager.HEIGHT_GETHEIGHT_RET;
         }
@@ -195,7 +195,7 @@ public sealed class BSTerrainMesh : BSTerrainPhys
     // The passed position is relative to the base of the region.
     public override float GetWaterLevelAtXYZ(Vector3 pos)
     {
-        return PhysicsScene.SimpleWaterLevel;
+        return m_physicsScene.SimpleWaterLevel;
     }
 
     // Convert the passed heightmap to mesh information suitable for CreateMeshShape2().
diff --git a/OpenSim/Region/Physics/BulletSPlugin/BulletSimData.cs b/OpenSim/Region/Physics/BulletSPlugin/BulletSimData.cs
index 8012d91..971ff9f 100755
--- a/OpenSim/Region/Physics/BulletSPlugin/BulletSimData.cs
+++ b/OpenSim/Region/Physics/BulletSPlugin/BulletSimData.cs
@@ -104,11 +104,11 @@ public class BulletShape
 {
     public BulletShape()
     {
-        type = BSPhysicsShapeType.SHAPE_UNKNOWN;
+        shapeType = BSPhysicsShapeType.SHAPE_UNKNOWN;
         shapeKey = (System.UInt64)FixedShapeKey.KEY_NONE;
         isNativeShape = false;
     }
-    public BSPhysicsShapeType type;
+    public BSPhysicsShapeType shapeType;
     public System.UInt64 shapeKey;
     public bool isNativeShape;
 
@@ -133,7 +133,7 @@ public class BulletShape
         buff.Append("<p=");
         buff.Append(AddrString);
         buff.Append(",s=");
-        buff.Append(type.ToString());
+        buff.Append(shapeType.ToString());
         buff.Append(",k=");
         buff.Append(shapeKey.ToString("X"));
         buff.Append(",n=");
@@ -224,42 +224,43 @@ public static class BulletSimData
 // As mentioned above, don't use the CollisionFilterGroups definitions directly in the code
 //     but, instead, use references to this dictionary. Finding and debugging
 //     collision flag problems will be made easier.
-public static Dictionary<CollisionType, CollisionTypeFilterGroup> CollisionTypeMasks 
+public static Dictionary<CollisionType, CollisionTypeFilterGroup> CollisionTypeMasks
             = new Dictionary<CollisionType, CollisionTypeFilterGroup>()
 {
-    { CollisionType.Avatar, 
-                new CollisionTypeFilterGroup(CollisionType.Avatar, 
-                                (uint)CollisionFilterGroups.BCharacterGroup, 
+    { CollisionType.Avatar,
+                new CollisionTypeFilterGroup(CollisionType.Avatar,
+                                (uint)CollisionFilterGroups.BCharacterGroup,
                                 (uint)CollisionFilterGroups.BAllGroup)
     },
-    { CollisionType.Groundplane, 
-                new CollisionTypeFilterGroup(CollisionType.Groundplane, 
-                                (uint)CollisionFilterGroups.BGroundPlaneGroup, 
-                                (uint)CollisionFilterGroups.BAllGroup)
+    { CollisionType.Groundplane,
+                new CollisionTypeFilterGroup(CollisionType.Groundplane,
+                                (uint)CollisionFilterGroups.BGroundPlaneGroup,
+                                // (uint)CollisionFilterGroups.BAllGroup)
+                                (uint)(CollisionFilterGroups.BCharacterGroup | CollisionFilterGroups.BSolidGroup))
     },
-    { CollisionType.Terrain, 
-                new CollisionTypeFilterGroup(CollisionType.Terrain, 
-                                (uint)CollisionFilterGroups.BTerrainGroup, 
+    { CollisionType.Terrain,
+                new CollisionTypeFilterGroup(CollisionType.Terrain,
+                                (uint)CollisionFilterGroups.BTerrainGroup,
                                 (uint)(CollisionFilterGroups.BAllGroup & ~CollisionFilterGroups.BStaticGroup))
     },
-    { CollisionType.Static, 
-                new CollisionTypeFilterGroup(CollisionType.Static, 
-                                (uint)CollisionFilterGroups.BStaticGroup, 
+    { CollisionType.Static,
+                new CollisionTypeFilterGroup(CollisionType.Static,
+                                (uint)CollisionFilterGroups.BStaticGroup,
                                 (uint)(CollisionFilterGroups.BCharacterGroup | CollisionFilterGroups.BSolidGroup))
     },
-    { CollisionType.Dynamic, 
-                new CollisionTypeFilterGroup(CollisionType.Dynamic, 
-                                (uint)CollisionFilterGroups.BSolidGroup, 
+    { CollisionType.Dynamic,
+                new CollisionTypeFilterGroup(CollisionType.Dynamic,
+                                (uint)CollisionFilterGroups.BSolidGroup,
                                 (uint)(CollisionFilterGroups.BAllGroup))
     },
-    { CollisionType.VolumeDetect, 
-                new CollisionTypeFilterGroup(CollisionType.VolumeDetect, 
-                                (uint)CollisionFilterGroups.BSensorTrigger, 
+    { CollisionType.VolumeDetect,
+                new CollisionTypeFilterGroup(CollisionType.VolumeDetect,
+                                (uint)CollisionFilterGroups.BSensorTrigger,
                                 (uint)(~CollisionFilterGroups.BSensorTrigger))
     },
     { CollisionType.LinksetChild,
-                new CollisionTypeFilterGroup(CollisionType.LinksetChild, 
-                                (uint)CollisionFilterGroups.BLinksetChildGroup, 
+                new CollisionTypeFilterGroup(CollisionType.LinksetChild,
+                                (uint)CollisionFilterGroups.BLinksetChildGroup,
                                 (uint)(CollisionFilterGroups.BNoneGroup))
                                 // (uint)(CollisionFilterGroups.BCharacterGroup | CollisionFilterGroups.BSolidGroup))
     },
diff --git a/OpenSim/Region/Physics/BulletSPlugin/BulletSimTODO.txt b/OpenSim/Region/Physics/BulletSPlugin/BulletSimTODO.txt
index 8a15abe..0453376 100755
--- a/OpenSim/Region/Physics/BulletSPlugin/BulletSimTODO.txt
+++ b/OpenSim/Region/Physics/BulletSPlugin/BulletSimTODO.txt
@@ -1,65 +1,61 @@
-CURRENT PRIORITIES
+CURRENT PROBLEMS TO FIX AND/OR LOOK AT
 =================================================
-Use the HACD convex hull routine in Bullet rather than the C# version.  
-        Speed up hullifying large meshes.
+Vehicle buoyancy. Computed correctly? Possibly creating very large effective mass.
+    Interaction of llSetBuoyancy and vehicle buoyancy. Should be additive?
+    Negative buoyancy computed correctly
+Center-of-gravity
+Computation of mesh mass. How done? How should it be done?
 Enable vehicle border crossings (at least as poorly as ODE)
         Terrain skirts
         Avatar created in previous region and not new region when crossing border
         Vehicle recreated in new sim at small Z value (offset from root value?) (DONE)
-Lock axis
+User settable terrain mesh
+        Allow specifying as convex or concave and use different getHeight functions depending
+Boats, when turning nose down into the water
+        Acts like rotation around Z is also effecting rotation around X and Y
 Deleting a linkset while standing on the root will leave the physical shape of the root behind.
         Not sure if it is because standing on it. Done with large prim linksets.
 Linkset child rotations.
         Nebadon spiral tube has middle sections which are rotated wrong.
         Select linked spiral tube. Delink and note where the middle section ends up.
-Vehicle angular vertical attraction
-vehicle angular banking
-Center-of-gravity
-Vehicle angular deflection
-        Preferred orientation angular correction fix
-when should angular and linear motor targets be zeroed? when selected?
-        Need a vehicle.clear()? Or an 'else' in prestep if not physical.
 Teravus llMoveToTarget script debug
         Mixing of hover, buoyancy/gravity, moveToTarget, into one force
         Setting hover height to zero disables hover even if hover flags are on (from SL wiki)
 limitMotorUp calibration (more down?)
 llRotLookAt
 llLookAt
-Avatars walking up stairs (HALF DONE)
-Avatar movement
-        flying into a wall doesn't stop avatar who keeps appearing to move through the obstacle (DONE)
-        walking up stairs is not calibrated correctly (stairs out of Kepler cabin)
-        avatar capsule rotation completed (NOT DONE - Bullet's capsule shape is not the solution)
+Convert to avatar mesh capsule. Include rotation of capsule.
 Vehicle script tuning/debugging
         Avanti speed script
         Weapon shooter script
 Move material definitions (friction, ...) into simulator.
-Add material densities to the material types.
-Terrain detail: double terrain mesh detail
+osGetPhysicsEngineVerion() and create a version code for the C++ DLL
 One sided meshes? Should terrain be built into a closed shape?
         When meshes get partially wedged into the terrain, they cannot push themselves out.
         It is possible that Bullet processes collisions whether entering or leaving a mesh.
         Ref: http://bulletphysics.org/Bullet/phpBB3/viewtopic.php?t=4869
+Small physical objects do not interact correctly
+    Create chain of .5x.5x.1 torui and make all but top physical so to hang.
+        The chain will fall apart and pairs will dance around on ground
+    Chains of 1x1x.2 will stay connected but will dance.
+    Chains above 2x2x.4 are more stable and get stablier as torui get larger.
 
 VEHICLES TODO LIST:
 =================================================
-Border crossing with linked vehicle causes crash
-        20121129.1411: editting/moving phys object across region boundries causes crash
-            getPos-> btRigidBody::upcast -> getBodyType -> BOOM
-Vehicles (Move smoothly)
+LINEAR_MOTOR_DIRECTION values should be clamped to reasonable numbers.
+        What are the limits in SL?
+        Same for other velocity settings.
+UBit improvements to remove rubber-banding of avatars sitting on vehicle child prims:
+        https://github.com/UbitUmarov/Ubit-opensim
 Some vehicles should not be able to turn if no speed or off ground.
-What to do if vehicle and prim buoyancy differ?
 Cannot edit/move a vehicle being ridden: it jumps back to the origional position.
 Neb car jiggling left and right
         Happens on terrain and any other mesh object. Flat cubes are much smoother.
         This has been reduced but not eliminated.
 Implement referenceFrame for all the motion routines.
-For limitMotorUp, use raycast down to find if vehicle is in the air.
 Verify llGetVel() is returning a smooth and good value for vehicle movement.
 llGetVel() should return the root's velocity if requested in a child prim.
 Implement function efficiency for lineaar and angular motion.
-After getting off a vehicle, the root prim is phantom (can be walked through)
-    Need to force a position update for the root prim after compound shape destruction
 Linkset explosion after three "rides" on Nebadon lite vehicle (LinksetConstraint)
 Remove vehicle angular velocity zeroing in BSPrim.UpdateProperties().
         A kludge that isn't fixing the real problem of Bullet adding extra motion.
@@ -68,11 +64,10 @@ Incorporate inter-relationship of angular corrections. For instance, angularDefl
         creates over-correction and over-shoot and wabbling.
 Vehicle attributes are not restored when a vehicle is rezzed on region creation
         Create vehicle, setup vehicle properties, restart region, vehicle is not reinitialized.
+What to do if vehicle and prim buoyancy differ?
 
 GENERAL TODO LIST:
 =================================================
-Explore btGImpactMeshShape as alternative to convex hulls for simplified physical objects.
-        Regular triangle meshes don't do physical collisions.
 Resitution of a prim works on another prim but not on terrain.
         The dropped prim doesn't bounce properly on the terrain.
 Add a sanity check for PIDTarget location.
@@ -98,29 +93,15 @@ Revisit CollisionMargin. Builders notice the 0.04 spacing between prims.
 Duplicating a physical prim causes old prim to jump away
         Dup a phys prim and the original become unselected and thus interacts w/ selected prim.
 Scenes with hundred of thousands of static objects take a lot of physics CPU time.
-BSPrim.Force should set a continious force on the prim. The force should be
-        applied each tick.  Some limits?
 Gun sending shooter flying.
 Collision margin (gap between physical objects lying on each other)
 Boundry checking (crashes related to crossing boundry)
     Add check for border edge position for avatars and objects.
     Verify the events are created for border crossings.
-Avatar rotation (check out changes to ScenePresence for physical rotation)
-Avatar running (what does phys engine need to do?)
-Small physical objects do not interact correctly
-    Create chain of .5x.5x.1 torui and make all but top physical so to hang.
-        The chain will fall apart and pairs will dance around on ground
-    Chains of 1x1x.2 will stay connected but will dance.
-    Chains above 2x2x.4 are more stable and get stablier as torui get larger.
-Add PID motor for avatar movement (slow to stop, ...)
-setForce should set a constant force. Different than AddImpulse.
-Implement raycast.
 Implement ShapeCollection.Dispose()
-Implement water as a plain so raycasting and collisions can happen with same.
+Implement water as a plain or mesh so raycasting and collisions can happen with same.
 Add collision penetration return
         Add field passed back by BulletSim.dll and fill with info in ManifoldConstact.GetDistance()
-Add osGetPhysicsEngineName() so scripters can tell whether BulletSim or ODE
-        Also osGetPhysicsEngineVerion() maybe.
 Linkset.Position and Linkset.Orientation requre rewrite to properly return
         child position. LinksetConstraint acts like it's at taint time!!
 Implement LockAngularMotion -- implements llSetStatus(ROTATE_AXIS_*, T/F)
@@ -132,9 +113,6 @@ Selecting and deselecting physical objects causes CPU processing time to jump
 Re-implement buoyancy as a separate force on the object rather than diddling gravity.
         Register a pre-step event to add the force.
 More efficient memory usage when passing hull information from BSPrim to BulletSim
-Avatar movement motor check for zero or small movement. Somehow suppress small movements
-        when avatar has stopped and is just standing. Simple test for near zero has
-        the problem of preventing starting up (increase from zero) especially when falling.
 Physical and phantom will drop through the terrain
 
 
@@ -168,6 +146,7 @@ Eliminate collisions between objects in a linkset. (LinksetConstraint)
 
 MORE
 ======================================================
+Compute avatar size and scale correctly. Now it is a bit off from the capsule size.
 Create tests for different interface components
         Have test objects/scripts measure themselves and turn color if correct/bad
         Test functions in SL and calibrate correctness there
@@ -176,7 +155,6 @@ Do we need to do convex hulls all the time? Can complex meshes be left meshes?
         There is some problem with meshes and collisions
         Hulls are not as detailed as meshes. Hulled vehicles insides are different shape.
 Debounce avatar contact so legs don't keep folding up when standing.
-Implement LSL physics controls. Like STATUS_ROTATE_X.
 Add border extensions to terrain to help region crossings and objects leaving region.
 Use a different capsule shape for avatar when sitting
         LL uses a pyrimidal shape scaled by the avatar's bounding box
@@ -209,8 +187,6 @@ Keep avatar scaling correct. http://pennycow.blogspot.fr/2011/07/matter-of-scale
 
 INTERNAL IMPROVEMENT/CLEANUP
 =================================================
-Can the 'inTaintTime' flag be cleaned up and used? For instance, a call to
-        BSScene.TaintedObject() could immediately execute the callback if already in taint time.
 Create the physical wrapper classes (BulletBody, BulletShape) by methods on
         BSAPITemplate and make their actual implementation Bullet engine specific.
         For the short term, just call the existing functions in ShapeCollection.
@@ -344,3 +320,60 @@ Angular motion around Z moves the vehicle in world Z and not vehicle Z in ODE.
         Verify that angular motion specified around Z moves in the vehicle coordinates.
         DONE 20130120: BulletSim properly applies force in vehicle relative coordinates.
 Nebadon vehicles turning funny in arena (DONE)
+Lock axis (DONE 20130401)
+Terrain detail: double terrain mesh detail (DONE)
+Use the HACD convex hull routine in Bullet rather than the C# version.  
+        Speed up hullifying large meshes. (DONE)
+Vehicle ride, get up, ride again. Second time vehicle does not act correctly.
+        Have to rez new vehicle and delete the old to fix situation.
+        (DONE 20130520: normalize rotations)
+Hitting RESET on Nebadon's vehicle while riding causes vehicle to get into odd
+        position state where it will not settle onto ground properly, etc
+        (DONE 20130520: normalize rotations)
+Two of Nebadon vehicles in a sim max the CPU. This is new.
+        (DONE 20130520: two problems: if asset failed to mesh, constantly refetched
+        asset; vehicle was sending too many messages to all linkset members)
+Add material densities to the material types. (WILL NOT BE DONE: not how it is done)
+Avatars walking up stairs (DONE)
+Avatar movement
+        flying into a wall doesn't stop avatar who keeps appearing to move through the obstacle (DONE)
+        walking up stairs is not calibrated correctly (stairs out of Kepler cabin) (DONE)
+        avatar capsule rotation completed (NOT DONE - Bullet's capsule shape is not the solution)
+After getting off a vehicle, the root prim is phantom (can be walked through)
+    Need to force a position update for the root prim after compound shape destruction
+        (DONE)
+Explore btGImpactMeshShape as alternative to convex hulls for simplified physical objects.
+        Regular triangle meshes don't do physical collisions.
+        (DONE: discovered GImpact is VERY CPU intensive)
+Script changing rotation of child prim while vehicle moving (eg turning wheel) causes
+        the wheel to appear to jump back. Looks like sending position from previous update.
+        (DONE: redo of compound linksets fixed problem)
+Refarb compound linkset creation to create a pseudo-root for center-of-mass
+        Let children change their shape to physical indendently and just add shapes to compound
+        (DONE: redo of compound linkset fixed problem)
+Vehicle angular vertical attraction     (DONE: vegaslon code)
+vehicle angular banking (DONE: vegaslon code)
+Vehicle angular deflection      (DONE: vegaslon code)
+        Preferred orientation angular correction fix
+Vehicles (Move smoothly)
+For limitMotorUp, use raycast down to find if vehicle is in the air.
+        (WILL NOT BE DONE: gravity does the job well enough)
+BSPrim.Force should set a continious force on the prim. The force should be
+        applied each tick.  Some limits?
+        (DONE: added physical actors. Implemented SetForce, SetTorque, ...)
+Implement LSL physics controls. Like STATUS_ROTATE_X. (DONE)
+Add osGetPhysicsEngineName() so scripters can tell whether BulletSim or ODE
+Avatar rotation (check out changes to ScenePresence for physical rotation) (DONE)
+Avatar running (what does phys engine need to do?) (DONE: multiplies run factor by walking force)
+setForce should set a constant force. Different than AddImpulse. (DONE)
+Add PID motor for avatar movement (slow to stop, ...) (WNBD: current works ok)
+Avatar movement motor check for zero or small movement. Somehow suppress small movements
+        when avatar has stopped and is just standing. Simple test for near zero has
+        the problem of preventing starting up (increase from zero) especially when falling.
+        (DONE: avatar movement actor knows if standing on stationary object and zeros motion)
+Can the 'inTaintTime' flag be cleaned up and used? For instance, a call to
+        BSScene.TaintedObject() could immediately execute the callback if already in taint time.
+        (DONE)
+
+
+
diff --git a/OpenSim/Region/Physics/BulletSPlugin/Properties/AssemblyInfo.cs b/OpenSim/Region/Physics/BulletSPlugin/Properties/AssemblyInfo.cs
index 02b03a8..d069178 100644
--- a/OpenSim/Region/Physics/BulletSPlugin/Properties/AssemblyInfo.cs
+++ b/OpenSim/Region/Physics/BulletSPlugin/Properties/AssemblyInfo.cs
@@ -29,5 +29,5 @@ using System.Runtime.InteropServices;
 //      Build Number
 //      Revision
 //
-[assembly: AssemblyVersion("0.7.6.*")]
+[assembly: AssemblyVersion("0.8.0.*")]
 
diff --git a/OpenSim/Region/Physics/BulletSPlugin/Tests/BasicVehicles.cs b/OpenSim/Region/Physics/BulletSPlugin/Tests/BasicVehicles.cs
index 33232bd..48e74eb 100755
--- a/OpenSim/Region/Physics/BulletSPlugin/Tests/BasicVehicles.cs
+++ b/OpenSim/Region/Physics/BulletSPlugin/Tests/BasicVehicles.cs
@@ -57,6 +57,8 @@ public class BasicVehicles : OpenSimTestCase
     public void Init()
     {
         Dictionary<string, string> engineParams = new Dictionary<string, string>();
+        engineParams.Add("VehicleEnableAngularVerticalAttraction", "true");
+        engineParams.Add("VehicleAngularVerticalAttractionAlgorithm", "1");
         PhysicsScene = BulletSimTestsUtil.CreateBasicPhysicsEngine(engineParams);
 
         PrimitiveBaseShape pbs = PrimitiveBaseShape.CreateSphere();
@@ -114,21 +116,25 @@ 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.
-        TestVehicle.VehicleController.ProcessFloatVehicleParam(Vehicle.VERTICAL_ATTRACTION_EFFICIENCY, efficiency);
-        TestVehicle.VehicleController.ProcessFloatVehicleParam(Vehicle.VERTICAL_ATTRACTION_TIMESCALE, timeScale);
-        TestVehicle.VehicleController.enableAngularVerticalAttraction = true;
-
-        TestVehicle.IsPhysical = true;
-        PhysicsScene.ProcessTaints();
-
-        // Step the simulator a bunch of times and vertical attraction should orient the vehicle up
-        for (int ii = 0; ii < simSteps; ii++)
+        BSDynamics vehicleActor = TestVehicle.GetVehicleActor(true /* createIfNone */);
+        if (vehicleActor != null)
         {
-            TestVehicle.VehicleController.ForgetKnownVehicleProperties();
-            TestVehicle.VehicleController.ComputeAngularVerticalAttraction();
-            TestVehicle.VehicleController.PushKnownChanged();
-
-            PhysicsScene.Simulate(simulationTimeStep);
+            vehicleActor.ProcessFloatVehicleParam(Vehicle.VERTICAL_ATTRACTION_EFFICIENCY, efficiency);
+            vehicleActor.ProcessFloatVehicleParam(Vehicle.VERTICAL_ATTRACTION_TIMESCALE, timeScale);
+            // vehicleActor.enableAngularVerticalAttraction = true;
+
+            TestVehicle.IsPhysical = true;
+            PhysicsScene.ProcessTaints();
+
+            // Step the simulator a bunch of times and vertical attraction should orient the vehicle up
+            for (int ii = 0; ii < simSteps; ii++)
+            {
+                vehicleActor.ForgetKnownVehicleProperties();
+                vehicleActor.ComputeAngularVerticalAttraction();
+                vehicleActor.PushKnownChanged();
+
+                PhysicsScene.Simulate(simulationTimeStep);
+            }
         }
 
         TestVehicle.IsPhysical = false;
diff --git a/OpenSim/Region/Physics/ConvexDecompositionDotNet/Properties/AssemblyInfo.cs b/OpenSim/Region/Physics/ConvexDecompositionDotNet/Properties/AssemblyInfo.cs
index f611b9a..b8cf624 100644
--- a/OpenSim/Region/Physics/ConvexDecompositionDotNet/Properties/AssemblyInfo.cs
+++ b/OpenSim/Region/Physics/ConvexDecompositionDotNet/Properties/AssemblyInfo.cs
@@ -32,5 +32,5 @@ using System.Runtime.InteropServices;
 // You can specify all the values or you can default the Build and Revision Numbers 
 // by using the '*' as shown below:
 // [assembly: AssemblyVersion("1.0.*")]
-[assembly: AssemblyVersion("0.7.6.*")]
+[assembly: AssemblyVersion("0.8.0.*")]
 
diff --git a/OpenSim/Region/Physics/Manager/AssemblyInfo.cs b/OpenSim/Region/Physics/Manager/AssemblyInfo.cs
index 5da3956..10e850e 100644
--- a/OpenSim/Region/Physics/Manager/AssemblyInfo.cs
+++ b/OpenSim/Region/Physics/Manager/AssemblyInfo.cs
@@ -55,4 +55,4 @@ using System.Runtime.InteropServices;
 // You can specify all values by your own or you can build default build and revision
 // numbers with the '*' character (the default):
 
-[assembly : AssemblyVersion("0.7.6.*")]
+[assembly : AssemblyVersion("0.8.0.*")]
diff --git a/OpenSim/Region/Physics/Manager/PhysicsActor.cs b/OpenSim/Region/Physics/Manager/PhysicsActor.cs
index 7cd364b..44bfd42 100644
--- a/OpenSim/Region/Physics/Manager/PhysicsActor.cs
+++ b/OpenSim/Region/Physics/Manager/PhysicsActor.cs
@@ -415,6 +415,12 @@ namespace OpenSim.Region.Physics.Manager
         public virtual PhysicsActor ParentActor { get { return this; } }
         
 
+        // Extendable interface for new, physics engine specific operations
+        public virtual object Extension(string pFunct, params object[] pParams)
+        {
+            // A NOP of the physics engine does not implement this feature
+            return null;
+        }
     }
 
     public class NullPhysicsActor : PhysicsActor
diff --git a/OpenSim/Region/Physics/Manager/PhysicsScene.cs b/OpenSim/Region/Physics/Manager/PhysicsScene.cs
index 20a70b4..dd9bbc1 100644
--- a/OpenSim/Region/Physics/Manager/PhysicsScene.cs
+++ b/OpenSim/Region/Physics/Manager/PhysicsScene.cs
@@ -25,10 +25,13 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
+using System;
 using System.Collections.Generic;
 using System.Reflection;
+
 using log4net;
 using Nini.Config;
+
 using OpenSim.Framework;
 using OpenMetaverse;
 
@@ -386,5 +389,12 @@ namespace OpenSim.Region.Physics.Manager
         {
             return 0;
         }
+
+        // Extendable interface for new, physics engine specific operations
+        public virtual object Extension(string pFunct, params object[] pParams)
+        {
+            // A NOP if the extension thing is not implemented by the physics engine
+            return null;
+        }
     }
 }
diff --git a/OpenSim/Region/Physics/Meshing/Meshmerizer.cs b/OpenSim/Region/Physics/Meshing/Meshmerizer.cs
index a32f401..d67d4d2 100644
--- a/OpenSim/Region/Physics/Meshing/Meshmerizer.cs
+++ b/OpenSim/Region/Physics/Meshing/Meshmerizer.cs
@@ -40,7 +40,6 @@ using log4net;
 using Nini.Config;
 using System.Reflection;
 using System.IO;
-using ComponentAce.Compression.Libs.zlib;
 
 namespace OpenSim.Region.Physics.Meshing
 {
@@ -64,6 +63,7 @@ namespace OpenSim.Region.Physics.Meshing
     public class Meshmerizer : IMesher
     {
         private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+        private static string LogHeader = "[MESH]";
 
         // Setting baseDir to a path will enable the dumping of raw files
         // raw files can be imported by blender so a visual inspection of the results can be done
@@ -72,6 +72,8 @@ namespace OpenSim.Region.Physics.Meshing
 #else
         private const string baseDir = null; //"rawFiles";
 #endif
+        // If 'true', lots of DEBUG logging of asset parsing details
+        private bool debugDetail = false;
 
         private bool cacheSculptMaps = true;
         private string decodedSculptMapPath = null;
@@ -79,6 +81,9 @@ namespace OpenSim.Region.Physics.Meshing
 
         private float minSizeForComplexMesh = 0.2f; // prims with all dimensions smaller than this will have a bounding box mesh
 
+        private List<List<Vector3>> mConvexHulls = null;
+        private List<Vector3> mBoundingHull = null;
+
         private Dictionary<ulong, Mesh> m_uniqueMeshes = new Dictionary<ulong, Mesh>();
 
         public Meshmerizer(IConfigSource config)
@@ -88,8 +93,11 @@ namespace OpenSim.Region.Physics.Meshing
 
             decodedSculptMapPath = start_config.GetString("DecodedSculptMapPath","j2kDecodeCache");
             cacheSculptMaps = start_config.GetBoolean("CacheSculptMaps", cacheSculptMaps);
-            if(mesh_config != null)
+            if (mesh_config != null)
+            {
                 useMeshiesPhysicsMesh = mesh_config.GetBoolean("UseMeshiesPhysicsMesh", useMeshiesPhysicsMesh);
+                debugDetail = mesh_config.GetBoolean("LogMeshDetails", debugDetail);
+            }
 
             try
             {
@@ -319,6 +327,9 @@ namespace OpenSim.Region.Physics.Meshing
             faces = new List<Face>();
             OSD meshOsd = null;
 
+            mConvexHulls = null;
+            mBoundingHull = null;
+
             if (primShape.SculptData.Length <= 0)
             {
                 // XXX: At the moment we can not log here since ODEPrim, for instance, ends up triggering this
@@ -355,9 +366,139 @@ namespace OpenSim.Region.Physics.Meshing
                 OSDMap physicsParms = null;
                 OSDMap map = (OSDMap)meshOsd;
                 if (map.ContainsKey("physics_shape"))
+                {
                     physicsParms = (OSDMap)map["physics_shape"]; // old asset format
+                    if (debugDetail) m_log.DebugFormat("{0} prim='{1}': using 'physics_shape' mesh data", LogHeader, primName);
+                }
                 else if (map.ContainsKey("physics_mesh"))
+                {
                     physicsParms = (OSDMap)map["physics_mesh"]; // new asset format
+                    if (debugDetail) m_log.DebugFormat("{0} prim='{1}':using 'physics_mesh' mesh data", LogHeader, primName);
+                }
+                else if (map.ContainsKey("medium_lod"))
+                {
+                    physicsParms = (OSDMap)map["medium_lod"]; // if no physics mesh, try to fall back to medium LOD display mesh
+                    if (debugDetail) m_log.DebugFormat("{0} prim='{1}':using 'medium_lod' mesh data", LogHeader, primName);
+                }
+                else if (map.ContainsKey("high_lod"))
+                {
+                    physicsParms = (OSDMap)map["high_lod"]; // if all else fails, use highest LOD display mesh and hope it works :)
+                    if (debugDetail) m_log.DebugFormat("{0} prim='{1}':using 'high_lod' mesh data", LogHeader, primName);
+                }
+
+                if (map.ContainsKey("physics_convex"))
+                { // pull this out also in case physics engine can use it
+                    OSD convexBlockOsd = null;
+                    try
+                    {
+                        OSDMap convexBlock = (OSDMap)map["physics_convex"];
+                        {
+                            int convexOffset = convexBlock["offset"].AsInteger() + (int)start;
+                            int convexSize = convexBlock["size"].AsInteger();
+
+                            byte[] convexBytes = new byte[convexSize];
+                            
+                            System.Buffer.BlockCopy(primShape.SculptData, convexOffset, convexBytes, 0, convexSize);
+                            
+                            try
+                            {
+                                convexBlockOsd = DecompressOsd(convexBytes);
+                            }
+                            catch (Exception e)
+                            {
+                                m_log.ErrorFormat("{0} prim='{1}': exception decoding convex block: {2}", LogHeader, primName, e);
+                                //return false;
+                            }
+                        }
+                        
+                        if (convexBlockOsd != null && convexBlockOsd is OSDMap)
+                        {
+                            convexBlock = convexBlockOsd as OSDMap;
+
+                            if (debugDetail)
+                            {
+                                string keys = LogHeader + " keys found in convexBlock: ";
+                                foreach (KeyValuePair<string, OSD> kvp in convexBlock)
+                                    keys += "'" + kvp.Key + "' ";
+                                m_log.Debug(keys);
+                            }
+
+                            Vector3 min = new Vector3(-0.5f, -0.5f, -0.5f);
+                            if (convexBlock.ContainsKey("Min")) min = convexBlock["Min"].AsVector3();
+                            Vector3 max = new Vector3(0.5f, 0.5f, 0.5f);
+                            if (convexBlock.ContainsKey("Max")) max = convexBlock["Max"].AsVector3();
+
+                            List<Vector3> boundingHull = null;
+
+                            if (convexBlock.ContainsKey("BoundingVerts"))
+                            {
+                                byte[] boundingVertsBytes = convexBlock["BoundingVerts"].AsBinary();
+                                boundingHull = new List<Vector3>();
+                                for (int i = 0; i < boundingVertsBytes.Length; )
+                                {
+                                    ushort uX = Utils.BytesToUInt16(boundingVertsBytes, i); i += 2;
+                                    ushort uY = Utils.BytesToUInt16(boundingVertsBytes, i); i += 2;
+                                    ushort uZ = Utils.BytesToUInt16(boundingVertsBytes, i); i += 2;
+
+                                    Vector3 pos = new Vector3(
+                                        Utils.UInt16ToFloat(uX, min.X, max.X),
+                                        Utils.UInt16ToFloat(uY, min.Y, max.Y),
+                                        Utils.UInt16ToFloat(uZ, min.Z, max.Z)
+                                    );
+
+                                    boundingHull.Add(pos);
+                                }
+
+                                mBoundingHull = boundingHull;
+                                if (debugDetail) m_log.DebugFormat("{0} prim='{1}': parsed bounding hull. nVerts={2}", LogHeader, primName, mBoundingHull.Count);
+                            }
+
+                            if (convexBlock.ContainsKey("HullList"))
+                            {
+                                byte[] hullList = convexBlock["HullList"].AsBinary();
+
+                                byte[] posBytes = convexBlock["Positions"].AsBinary();
+
+                                List<List<Vector3>> hulls = new List<List<Vector3>>();
+                                int posNdx = 0;
+
+                                foreach (byte cnt in hullList)
+                                {
+                                    int count = cnt == 0 ? 256 : cnt;
+                                    List<Vector3> hull = new List<Vector3>();
+
+                                    for (int i = 0; i < count; i++)
+                                    {
+                                        ushort uX = Utils.BytesToUInt16(posBytes, posNdx); posNdx += 2;
+                                        ushort uY = Utils.BytesToUInt16(posBytes, posNdx); posNdx += 2;
+                                        ushort uZ = Utils.BytesToUInt16(posBytes, posNdx); posNdx += 2;
+
+                                        Vector3 pos = new Vector3(
+                                            Utils.UInt16ToFloat(uX, min.X, max.X),
+                                            Utils.UInt16ToFloat(uY, min.Y, max.Y),
+                                            Utils.UInt16ToFloat(uZ, min.Z, max.Z)
+                                        );
+
+                                        hull.Add(pos);
+                                    }
+
+                                    hulls.Add(hull);
+                                }
+
+                                mConvexHulls = hulls;
+                                if (debugDetail) m_log.DebugFormat("{0} prim='{1}': parsed hulls. nHulls={2}", LogHeader, primName, mConvexHulls.Count);
+                            }
+                            else
+                            {
+                                if (debugDetail) m_log.DebugFormat("{0} prim='{1}' has physics_convex but no HullList", LogHeader, primName);
+                            }
+                        }
+                    }
+                    catch (Exception e)
+                    {
+                        m_log.WarnFormat("{0} exception decoding convex block: {1}", LogHeader, e);
+                    }
+                }
 
                 if (physicsParms == null)
                 {
@@ -374,34 +515,14 @@ namespace OpenSim.Region.Physics.Meshing
                 OSD decodedMeshOsd = new OSD();
                 byte[] meshBytes = new byte[physSize];
                 System.Buffer.BlockCopy(primShape.SculptData, physOffset, meshBytes, 0, physSize);
-//                        byte[] decompressed = new byte[physSize * 5];
+                //                        byte[] decompressed = new byte[physSize * 5];
                 try
                 {
-                    using (MemoryStream inMs = new MemoryStream(meshBytes))
-                    {
-                        using (MemoryStream outMs = new MemoryStream())
-                        {
-                            using (ZOutputStream zOut = new ZOutputStream(outMs))
-                            {
-                                byte[] readBuffer = new byte[2048];
-                                int readLen = 0;
-                                while ((readLen = inMs.Read(readBuffer, 0, readBuffer.Length)) > 0)
-                                {
-                                    zOut.Write(readBuffer, 0, readLen);
-                                }
-                                zOut.Flush();
-                                outMs.Seek(0, SeekOrigin.Begin);
-
-                                byte[] decompressedBuf = outMs.GetBuffer();
-
-                                decodedMeshOsd = OSDParser.DeserializeLLSDBinary(decompressedBuf);
-                            }
-                        }
-                    }
+                    decodedMeshOsd = DecompressOsd(meshBytes);
                 }
                 catch (Exception e)
                 {
-                    m_log.Error("[MESH]: exception decoding physical mesh: " + e.ToString());
+                    m_log.ErrorFormat("{0} prim='{1}': exception decoding physical mesh: {2}", LogHeader, primName, e);
                     return false;
                 }
 
@@ -410,7 +531,7 @@ namespace OpenSim.Region.Physics.Meshing
                 // physics_shape is an array of OSDMaps, one for each submesh
                 if (decodedMeshOsd is OSDArray)
                 {
-//                            Console.WriteLine("decodedMeshOsd for {0} - {1}", primName, Util.GetFormattedXml(decodedMeshOsd));
+                    //                            Console.WriteLine("decodedMeshOsd for {0} - {1}", primName, Util.GetFormattedXml(decodedMeshOsd));
 
                     decodedMeshOsdArray = (OSDArray)decodedMeshOsd;
                     foreach (OSD subMeshOsd in decodedMeshOsdArray)
@@ -418,6 +539,9 @@ namespace OpenSim.Region.Physics.Meshing
                         if (subMeshOsd is OSDMap)
                             AddSubMesh(subMeshOsd as OSDMap, size, coords, faces);
                     }
+                    if (debugDetail)
+                        m_log.DebugFormat("{0} {1}: mesh decoded. offset={2}, size={3}, nCoords={4}, nFaces={5}",
+                                            LogHeader, primName, physOffset, physSize, coords.Count, faces.Count);
                 }
             }
 
@@ -425,6 +549,42 @@ namespace OpenSim.Region.Physics.Meshing
         }
 
         /// <summary>
+        /// decompresses a gzipped OSD object
+        /// </summary>
+        /// <param name="decodedOsd"></param> the OSD object
+        /// <param name="meshBytes"></param>
+        /// <returns></returns>
+        private static OSD DecompressOsd(byte[] meshBytes)
+        {
+            OSD decodedOsd = null;
+
+            using (MemoryStream inMs = new MemoryStream(meshBytes))
+            {
+                using (MemoryStream outMs = new MemoryStream())
+                {
+                    using (DeflateStream decompressionStream = new DeflateStream(inMs, CompressionMode.Decompress))
+                    {
+                        byte[] readBuffer = new byte[2048];
+                        inMs.Read(readBuffer, 0, 2); // skip first 2 bytes in header
+                        int readLen = 0;
+
+                        while ((readLen = decompressionStream.Read(readBuffer, 0, readBuffer.Length)) > 0)
+                            outMs.Write(readBuffer, 0, readLen);
+
+                        outMs.Flush();
+
+                        outMs.Seek(0, SeekOrigin.Begin);
+
+                        byte[] decompressedBuf = outMs.GetBuffer();
+
+                        decodedOsd = OSDParser.DeserializeLLSDBinary(decompressedBuf);
+                    }
+                }
+            }
+            return decodedOsd;
+        }
+
+        /// <summary>
         /// Generate the co-ords and faces necessary to construct a mesh from the sculpt data the accompanies a prim.
         /// </summary>
         /// <param name="primName"></param>
@@ -469,10 +629,11 @@ namespace OpenSim.Region.Physics.Meshing
 
                 try
                 {
-                    OpenMetaverse.Imaging.ManagedImage unusedData;
-                    OpenMetaverse.Imaging.OpenJPEG.DecodeToImage(primShape.SculptData, out unusedData, out idata);
+                    OpenMetaverse.Imaging.ManagedImage managedImage;
+
+                    OpenMetaverse.Imaging.OpenJPEG.DecodeToImage(primShape.SculptData, out managedImage);
 
-                    if (idata == null)
+                    if (managedImage == null)
                     {
                         // In some cases it seems that the decode can return a null bitmap without throwing
                         // an exception
@@ -481,9 +642,12 @@ namespace OpenSim.Region.Physics.Meshing
                         return false;
                     }
 
-                    unusedData = null;
+                    if ((managedImage.Channels & OpenMetaverse.Imaging.ManagedImage.ImageChannels.Alpha) != 0)
+                        managedImage.ConvertChannels(managedImage.Channels & ~OpenMetaverse.Imaging.ManagedImage.ImageChannels.Alpha);
 
-                    //idata = CSJ2K.J2kImage.FromBytes(primShape.SculptData);
+                    Bitmap imgData = OpenMetaverse.Imaging.LoadTGAClass.LoadTGA(new MemoryStream(managedImage.ExportTGA()));
+                    idata = (Image)imgData;
+                    managedImage = null;
 
                     if (cacheSculptMaps)
                     {
@@ -700,6 +864,45 @@ namespace OpenSim.Region.Physics.Meshing
             return true;
         }
 
+        /// <summary>
+        /// temporary prototype code - please do not use until the interface has been finalized!
+        /// </summary>
+        /// <param name="size">value to scale the hull points by</param>
+        /// <returns>a list of vertices in the bounding hull if it exists and has been successfully decoded, otherwise null</returns>
+        public List<Vector3> GetBoundingHull(Vector3 size)
+        {
+            if (mBoundingHull == null)
+                return null;
+
+            List<Vector3> verts = new List<Vector3>();
+            foreach (var vert in mBoundingHull)
+                verts.Add(vert * size);
+
+            return verts;
+        }
+
+        /// <summary>
+        /// temporary prototype code - please do not use until the interface has been finalized!
+        /// </summary>
+        /// <param name="size">value to scale the hull points by</param>
+        /// <returns>a list of hulls if they exist and have been successfully decoded, otherwise null</returns>
+        public List<List<Vector3>> GetConvexHulls(Vector3 size)
+        {
+            if (mConvexHulls == null)
+                return null;
+
+            List<List<Vector3>> hulls = new List<List<Vector3>>();
+            foreach (var hull in mConvexHulls)
+            {
+                List<Vector3> verts = new List<Vector3>();
+                foreach (var vert in hull)
+                    verts.Add(vert * size);
+                hulls.Add(verts);
+            }
+
+            return hulls;
+        }
+
         public IMesh CreateMesh(String primName, PrimitiveBaseShape primShape, Vector3 size, float lod)
         {
             return CreateMesh(primName, primShape, size, lod, false, true);
diff --git a/OpenSim/Region/Physics/Meshing/Properties/AssemblyInfo.cs b/OpenSim/Region/Physics/Meshing/Properties/AssemblyInfo.cs
index 3de061a..8542753 100644
--- a/OpenSim/Region/Physics/Meshing/Properties/AssemblyInfo.cs
+++ b/OpenSim/Region/Physics/Meshing/Properties/AssemblyInfo.cs
@@ -29,5 +29,5 @@ using System.Runtime.InteropServices;
 //      Build Number
 //      Revision
 //
-[assembly: AssemblyVersion("0.7.6.*")]
+[assembly: AssemblyVersion("0.8.0.*")]
 
diff --git a/OpenSim/Region/Physics/OdePlugin/AssemblyInfo.cs b/OpenSim/Region/Physics/OdePlugin/AssemblyInfo.cs
index f477ed1..288cab5 100644
--- a/OpenSim/Region/Physics/OdePlugin/AssemblyInfo.cs
+++ b/OpenSim/Region/Physics/OdePlugin/AssemblyInfo.cs
@@ -55,4 +55,4 @@ using System.Runtime.InteropServices;
 // You can specify all values by your own or you can build default build and revision
 // numbers with the '*' character (the default):
 
-[assembly : AssemblyVersion("0.7.6.*")]
+[assembly : AssemblyVersion("0.8.0.*")]
diff --git a/OpenSim/Region/Physics/OdePlugin/ODEPrim.cs b/OpenSim/Region/Physics/OdePlugin/ODEPrim.cs
index d09aa62..b4b7e7f 100644
--- a/OpenSim/Region/Physics/OdePlugin/ODEPrim.cs
+++ b/OpenSim/Region/Physics/OdePlugin/ODEPrim.cs
@@ -108,7 +108,6 @@ namespace OpenSim.Region.Physics.OdePlugin
         private Vector3 m_taintAngularLock = Vector3.One;
         private IntPtr Amotor = IntPtr.Zero;
 
-        private object m_assetsLock = new object();
         private bool m_assetFailed = false;
 
         private Vector3 m_PIDTarget;
diff --git a/OpenSim/Region/Physics/OdePlugin/OdePlugin.cs b/OpenSim/Region/Physics/OdePlugin/OdePlugin.cs
index 07663b3..7e652fc 100644
--- a/OpenSim/Region/Physics/OdePlugin/OdePlugin.cs
+++ b/OpenSim/Region/Physics/OdePlugin/OdePlugin.cs
@@ -46,7 +46,7 @@ namespace OpenSim.Region.Physics.OdePlugin
     /// </summary>
     public class OdePlugin : IPhysicsPlugin
     {
-        private static readonly log4net.ILog m_log = log4net.LogManager.GetLogger(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType);
+//        private static readonly log4net.ILog m_log = log4net.LogManager.GetLogger(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType);
 
         private OdeScene m_scene;
 
diff --git a/OpenSim/Region/Physics/POSPlugin/AssemblyInfo.cs b/OpenSim/Region/Physics/POSPlugin/AssemblyInfo.cs
index 4289863..83be103 100644
--- a/OpenSim/Region/Physics/POSPlugin/AssemblyInfo.cs
+++ b/OpenSim/Region/Physics/POSPlugin/AssemblyInfo.cs
@@ -55,4 +55,4 @@ using System.Runtime.InteropServices;
 // You can specify all values by your own or you can build default build and revision
 // numbers with the '*' character (the default):
 
-[assembly : AssemblyVersion("0.7.6.*")]
+[assembly : AssemblyVersion("0.8.0.*")]
diff --git a/OpenSim/Region/Physics/UbitOdePlugin/ODECharacter.cs b/OpenSim/Region/Physics/UbitOdePlugin/ODECharacter.cs
index ecd5474..1c38246 100644
--- a/OpenSim/Region/Physics/UbitOdePlugin/ODECharacter.cs
+++ b/OpenSim/Region/Physics/UbitOdePlugin/ODECharacter.cs
@@ -79,6 +79,7 @@ namespace OpenSim.Region.Physics.OdePlugin
         private Vector3 _acceleration;
         private Vector3 m_rotationalVelocity;
         private Vector3 m_size;
+        private Vector3 m_collideNormal;
         private Quaternion m_orientation;
         private Quaternion m_orientation2D;
         private float m_mass = 80f;
@@ -96,6 +97,8 @@ namespace OpenSim.Region.Physics.OdePlugin
         private float m_feetOffset = 0;
         private float feetOff = 0;
         private float boneOff = 0;
+        private float AvaAvaSizeXsq = 0.3f;
+        private float AvaAvaSizeYsq = 0.2f;
 
         public float walkDivisor = 1.3f;
         public float runDivisor = 0.8f;
@@ -107,6 +110,7 @@ namespace OpenSim.Region.Physics.OdePlugin
 
         private bool _zeroFlag = false;
 
+
         private uint m_localID = 0;
         public bool m_returnCollisions = false;
         // taints and their non-tainted counterparts
@@ -136,7 +140,6 @@ namespace OpenSim.Region.Physics.OdePlugin
         public IntPtr Body = IntPtr.Zero;
         private OdeScene _parent_scene;
         private IntPtr capsule = IntPtr.Zero;
-        private IntPtr bbox = IntPtr.Zero;
         public IntPtr collider = IntPtr.Zero;
 
         public IntPtr Amotor = IntPtr.Zero;
@@ -152,9 +155,7 @@ namespace OpenSim.Region.Physics.OdePlugin
         public UUID m_uuid;
         public bool bad = false;
 
-        float mu;
-
-        
+        float mu;       
 
         public OdeCharacter(uint localID, String avName, OdeScene parent_scene, Vector3 pos, Vector3 pSize, float pfeetOffset, float density, float walk_divisor, float rundivisor)
         {
@@ -310,9 +311,9 @@ namespace OpenSim.Region.Physics.OdePlugin
             {
                 if (value)
                 {
-                    m_colliderfilter += 2;
-                    if (m_colliderfilter > 2)
-                        m_colliderfilter = 2;
+                    m_colliderfilter += 3;
+                    if (m_colliderfilter > 3)
+                        m_colliderfilter = 3;
                 }
                 else
                 {
@@ -327,6 +328,7 @@ namespace OpenSim.Region.Physics.OdePlugin
                 {
                     m_pidControllerActive = true;
                     m_iscolliding = true;
+                    m_freemove = false;
                 }
             }
         }
@@ -709,6 +711,11 @@ namespace OpenSim.Region.Physics.OdePlugin
 
             feetOff = bot + feetsz;
 
+            AvaAvaSizeXsq = 0.4f * sx;
+            AvaAvaSizeXsq *= AvaAvaSizeXsq;
+            AvaAvaSizeYsq = 0.5f * sy;
+            AvaAvaSizeYsq *= AvaAvaSizeYsq;
+
             _parent_scene.waitForSpaceUnlock(_parent_scene.CharsSpace);
 
             collider = d.HashSpaceCreate(_parent_scene.CharsSpace);
@@ -723,9 +730,8 @@ namespace OpenSim.Region.Physics.OdePlugin
                 r = m_size.Y;
             float l = m_size.Z - r;
             r *= 0.5f;
-            capsule = d.CreateCapsule(collider, r, l);
 
-            bbox = d.CreateBox(collider, m_size.X, m_size.Y, m_size.Z);
+            capsule = d.CreateCapsule(collider, r, l);
 
             m_mass = m_density * m_size.X * m_size.Y * m_size.Z;  // update mass
 
@@ -750,8 +756,6 @@ namespace OpenSim.Region.Physics.OdePlugin
             _position.Z = npositionZ;
 
             d.BodySetMass(Body, ref ShellMass);
-
-            d.GeomSetBody(bbox, Body);
             d.GeomSetBody(capsule, Body);
 
             // The purpose of the AMotor here is to keep the avatar's physical
@@ -821,14 +825,6 @@ namespace OpenSim.Region.Physics.OdePlugin
                 capsule = IntPtr.Zero;
             }
 
-            if (bbox != IntPtr.Zero)
-            {
-                _parent_scene.actor_name_map.Remove(bbox);
-                _parent_scene.waitForSpaceUnlock(collider);
-                d.GeomDestroy(bbox);
-                bbox = IntPtr.Zero;
-            }
-
             if (collider != IntPtr.Zero)
             {
                 d.SpaceDestroy(collider);
@@ -869,47 +865,107 @@ namespace OpenSim.Region.Physics.OdePlugin
             x = tx * cos - y * sin;
             y = tx * sin + y * cos;
         }
-
-
-        public bool Collide(IntPtr me, bool reverse, ref d.ContactGeom contact, ref bool feetcollision)
+      
+        public bool Collide(IntPtr me, IntPtr other, bool reverse, ref d.ContactGeom contact,
+                ref d.ContactGeom altContact , ref bool useAltcontact, ref bool feetcollision)
         {
             feetcollision = false;
-
-            Vector3 offset;
-
-            offset.X = contact.pos.X - _position.X;
-            offset.Y = contact.pos.Y - _position.Y;
+            useAltcontact = false;
 
             if (me == capsule)
             {
+                Vector3 offset;
+
                 float h = contact.pos.Z - _position.Z;
                 offset.Z = h - feetOff;
 
-                if (offset.Z > 0)
+                offset.X = contact.pos.X - _position.X;
+                offset.Y = contact.pos.Y - _position.Y;
+
+                d.GeomClassID gtype = d.GeomGetClass(other);
+                if (gtype == d.GeomClassID.CapsuleClass)
+                {
+                    Vector3 roff = offset * Quaternion.Inverse(m_orientation2D);
+                    float r = roff.X *roff.X / AvaAvaSizeXsq;
+                    r += (roff.Y * roff.Y) / AvaAvaSizeYsq;
+                    if (r > 1.0f)
+                        return false;
+
+                    float dp = 1.0f -(float)Math.Sqrt((double)r);
+                    if (dp > 0.05f)
+                        dp = 0.05f;
+
+                    contact.depth = dp;
+
+                    if (offset.Z < 0)
+                    {
+                        feetcollision = true;
+                        if (h < boneOff)
+                        {
+                            m_collideNormal.X = contact.normal.X;
+                            m_collideNormal.Y = contact.normal.Y;
+                            m_collideNormal.Z = contact.normal.Z;
+                            IsColliding = true;
+                        }
+                    }
                     return true;
+                }               
+/*
+                d.AABB aabb;
+                d.GeomGetAABB(other,out aabb);
+                float othertop = aabb.MaxZ - _position.Z;
+*/
+//                if (offset.Z > 0 || othertop > -feetOff || contact.normal.Z > 0.35f)
+                if (offset.Z > 0 || contact.normal.Z > 0.35f)
+                {
+                    if (offset.Z <= 0)
+                    {
+                        feetcollision = true;
+                        if (h < boneOff)
+                        {
+                            m_collideNormal.X = contact.normal.X;
+                            m_collideNormal.Y = contact.normal.Y;
+                            m_collideNormal.Z = contact.normal.Z;
+                            IsColliding = true;
+                        }
+                    }
+                    return true;
+                }
+
+                altContact = contact;
+                useAltcontact = true;
+
+                offset.Z -= 0.2f;
 
                 offset.Normalize();
 
+                if (contact.depth > 0.1f)
+                    contact.depth = 0.1f;
+
                 if (reverse)
                 {
-                    contact.normal.X = offset.X;
-                    contact.normal.Y = offset.Y;
-                    contact.normal.Z = offset.Z;
+                    altContact.normal.X = offset.X;
+                    altContact.normal.Y = offset.Y;
+                    altContact.normal.Z = offset.Z;
                 }
                 else
                 {
-                    contact.normal.X = -offset.X;
-                    contact.normal.Y = -offset.Y;
-                    contact.normal.Z = -offset.Z;
+                    altContact.normal.X = -offset.X;
+                    altContact.normal.Y = -offset.Y;
+                    altContact.normal.Z = -offset.Z;
                 }
+
                 feetcollision = true;
                 if (h < boneOff)
+                {
+                    m_collideNormal.X = contact.normal.X;
+                    m_collideNormal.Y = contact.normal.Y;
+                    m_collideNormal.Z = contact.normal.Z;
                     IsColliding = true;
+                }
+                return true;
             }
-            else
-                return false;
-
-            return true;
+            return false;
         }
 
         /// <summary>
@@ -986,6 +1042,9 @@ namespace OpenSim.Region.Physics.OdePlugin
             Vector3 vel = new Vector3(dtmp.X, dtmp.Y, dtmp.Z);
             float velLengthSquared = vel.LengthSquared();
 
+
+            Vector3 ctz = _target_velocity;
+
             float movementdivisor = 1f;
             //Ubit change divisions into multiplications below
             if (!m_alwaysRun)
@@ -993,13 +1052,16 @@ namespace OpenSim.Region.Physics.OdePlugin
             else
                 movementdivisor = 1 / runDivisor;
 
+            ctz.X *= movementdivisor;
+            ctz.Y *= movementdivisor;
+
             //******************************************
             // colide with land
 
             d.AABB aabb;
 //            d.GeomGetAABB(feetbox, out aabb);
             d.GeomGetAABB(capsule, out aabb);
-            float chrminZ = aabb.MinZ; ; // move up a bit
+            float chrminZ = aabb.MinZ; // move up a bit
             Vector3 posch = localpos;
 
             float ftmp;
@@ -1014,15 +1076,18 @@ namespace OpenSim.Region.Physics.OdePlugin
             float terrainheight = _parent_scene.GetTerrainHeightAtXY(posch.X, posch.Y);
             if (chrminZ < terrainheight)
             {
+                if (ctz.Z < 0)
+                    ctz.Z = 0;
+
+                Vector3 n = _parent_scene.GetTerrainNormalAtXY(posch.X, posch.Y);
                 float depth = terrainheight - chrminZ;
+
+                vec.Z = depth * PID_P * 50;
+
                 if (!flying)
-                {
-                    vec.Z = -vel.Z * PID_D * 1.5f + depth * PID_P * 50;
-                }
-                else
-                    vec.Z = depth * PID_P * 50;
+                    vec.Z += -vel.Z * PID_D;
 
-                if (depth < 0.1f)
+                if (depth < 0.2f)
                 {
                     m_colliderGroundfilter++;
                     if (m_colliderGroundfilter > 2)
@@ -1036,50 +1101,83 @@ namespace OpenSim.Region.Physics.OdePlugin
                             m_freemove = false;
                         }
 
+                        m_collideNormal.X = n.X;
+                        m_collideNormal.Y = n.Y;
+                        m_collideNormal.Z = n.Z;
+
                         m_iscollidingGround = true;
 
+
                         ContactPoint contact = new ContactPoint();
                         contact.PenetrationDepth = depth;
                         contact.Position.X = localpos.X;
                         contact.Position.Y = localpos.Y;
                         contact.Position.Z = terrainheight;
-                        contact.SurfaceNormal.X = 0.0f;
-                        contact.SurfaceNormal.Y = 0.0f;
-                        contact.SurfaceNormal.Z = -1f;
+                        contact.SurfaceNormal.X = -n.X;
+                        contact.SurfaceNormal.Y = -n.Y;
+                        contact.SurfaceNormal.Z = -n.Z;
                         contact.RelativeSpeed = -vel.Z;
                         contact.CharacterFeet = true;
                         AddCollisionEvent(0, contact);
 
-                        vec.Z *= 0.5f;
+//                        vec.Z *= 0.5f;
                     }
                 }
 
                 else
                 {
-                    m_colliderGroundfilter = 0;
-                    m_iscollidingGround = false;
+                    m_colliderGroundfilter -= 5;
+                    if (m_colliderGroundfilter <= 0)
+                    {
+                        m_colliderGroundfilter = 0;
+                        m_iscollidingGround = false;
+                    }
                 }
             }
             else
             {
-                m_colliderGroundfilter = 0;
-                m_iscollidingGround = false;
+                m_colliderGroundfilter -= 5;
+                if (m_colliderGroundfilter <= 0)
+                {
+                    m_colliderGroundfilter = 0;
+                    m_iscollidingGround = false;
+                }
             }
 
             
             //******************************************
+            if (!m_iscolliding)
+                m_collideNormal.Z = 0;
+
+            bool tviszero = (ctz.X == 0.0f && ctz.Y == 0.0f && ctz.Z == 0.0f);
+
 
-            bool tviszero = (_target_velocity.X == 0.0f && _target_velocity.Y == 0.0f && _target_velocity.Z == 0.0f);
 
-            //            if (!tviszero || m_iscolliding || velLengthSquared <0.01)
             if (!tviszero)
+            {
                 m_freemove = false;
 
+                // movement relative to surface if moving on it
+                // dont disturbe vertical movement, ie jumps
+                if (m_iscolliding && !flying && ctz.Z == 0 && m_collideNormal.Z > 0.2f && m_collideNormal.Z < 0.94f)
+                {
+                    float p = ctz.X * m_collideNormal.X + ctz.Y * m_collideNormal.Y;
+                    ctz.X *= (float)Math.Sqrt(1 - m_collideNormal.X * m_collideNormal.X);
+                    ctz.Y *= (float)Math.Sqrt(1 - m_collideNormal.Y * m_collideNormal.Y);
+                    ctz.Z -= p;
+                    if (ctz.Z < 0)
+                        ctz.Z *= 2;
+
+                }
+
+            }
+
+
             if (!m_freemove)
             {
 
                 //  if velocity is zero, use position control; otherwise, velocity control
-                if (tviszero && m_iscolliding)
+                if (tviszero && m_iscolliding && !flying)
                 {
                     //  keep track of where we stopped.  No more slippin' & slidin'
                     if (!_zeroFlag)
@@ -1094,12 +1192,18 @@ namespace OpenSim.Region.Physics.OdePlugin
                         // Avatar to Avatar collisions
                         // Prim to avatar collisions
 
-                        vec.X = -vel.X * PID_D + (_zeroPosition.X - localpos.X) * (PID_P * 2);
-                        vec.Y = -vel.Y * PID_D + (_zeroPosition.Y - localpos.Y) * (PID_P * 2);
+                        vec.X = -vel.X * PID_D * 2f + (_zeroPosition.X - localpos.X) * (PID_P * 5);
+                        vec.Y = -vel.Y * PID_D * 2f + (_zeroPosition.Y - localpos.Y) * (PID_P * 5);
+                        if(vel.Z > 0)
+                            vec.Z += -vel.Z * PID_D + (_zeroPosition.Z - localpos.Z) * PID_P;
+                        else
+                            vec.Z += (-vel.Z * PID_D + (_zeroPosition.Z - localpos.Z) * PID_P) * 0.2f;
+/*
                         if (flying)
                         {
                             vec.Z += -vel.Z * PID_D + (_zeroPosition.Z - localpos.Z) * PID_P;
                         }
+*/
                     }
                     //PidStatus = true;
                 }
@@ -1112,22 +1216,48 @@ namespace OpenSim.Region.Physics.OdePlugin
                     {
                         if (!flying)
                         {
-                            if (_target_velocity.Z > 0.0f)
+                            // we are on a surface
+                            if (ctz.Z > 0f)
+                            {
+                                // moving up or JUMPING
+                                vec.Z += (ctz.Z - vel.Z) * PID_D * 2f;
+                                vec.X += (ctz.X - vel.X) * (PID_D);
+                                vec.Y += (ctz.Y - vel.Y) * (PID_D);
+                            }
+                            else
                             {
-                                // We're colliding with something and we're not flying but we're moving
-                                // This means we're walking or running. JUMPING
-                                vec.Z += (_target_velocity.Z - vel.Z) * PID_D * 1.2f;// +(_zeroPosition.Z - localpos.Z) * PID_P;
+                                // we are moving down on a surface
+                                if (ctz.Z == 0)
+                                {
+                                    if (vel.Z > 0)
+                                        vec.Z -= vel.Z * PID_D * 2f;
+                                    vec.X += (ctz.X - vel.X) * (PID_D);
+                                    vec.Y += (ctz.Y - vel.Y) * (PID_D);
+                                }
+                                // intencionally going down
+                                else
+                                {
+                                    if (ctz.Z < vel.Z)
+                                        vec.Z += (ctz.Z - vel.Z) * PID_D;
+                                    else
+                                    {
+                                    }
+
+                                    if (Math.Abs(ctz.X) > Math.Abs(vel.X))
+                                        vec.X += (ctz.X - vel.X) * (PID_D);
+                                    if (Math.Abs(ctz.Y) > Math.Abs(vel.Y))
+                                        vec.Y += (ctz.Y - vel.Y) * (PID_D);
+                                }
                             }
+
                             // We're standing on something
-                            vec.X = ((_target_velocity.X * movementdivisor) - vel.X) * (PID_D);
-                            vec.Y = ((_target_velocity.Y * movementdivisor) - vel.Y) * (PID_D);
                         }
                         else
                         {
                             // We're flying and colliding with something
-                            vec.X = ((_target_velocity.X * movementdivisor) - vel.X) * (PID_D * 0.0625f);
-                            vec.Y = ((_target_velocity.Y * movementdivisor) - vel.Y) * (PID_D * 0.0625f);
-                            vec.Z += (_target_velocity.Z - vel.Z) * (PID_D);
+                            vec.X += (ctz.X - vel.X) * (PID_D * 0.0625f);
+                            vec.Y += (ctz.Y - vel.Y) * (PID_D * 0.0625f);
+                            vec.Z += (ctz.Z - vel.Z) * (PID_D * 0.0625f);
                         }
                     }
                     else // ie not colliding
@@ -1135,9 +1265,9 @@ namespace OpenSim.Region.Physics.OdePlugin
                         if (flying) //(!m_iscolliding && flying)
                         {
                             // we're in mid air suspended
-                            vec.X = ((_target_velocity.X * movementdivisor) - vel.X) * (PID_D * 1.667f);
-                            vec.Y = ((_target_velocity.Y * movementdivisor) - vel.Y) * (PID_D * 1.667f);
-                            vec.Z += (_target_velocity.Z - vel.Z) * (PID_D);
+                            vec.X += (ctz.X - vel.X) * (PID_D);
+                            vec.Y += (ctz.Y - vel.Y) * (PID_D);
+                            vec.Z += (ctz.Z - vel.Z) * (PID_D);
                         }
 
                         else
@@ -1146,8 +1276,11 @@ namespace OpenSim.Region.Physics.OdePlugin
                             // m_iscolliding includes collisions with the ground.
 
                             // d.Vector3 pos = d.BodyGetPosition(Body);
-                            vec.X = (_target_velocity.X - vel.X) * PID_D * 0.833f;
-                            vec.Y = (_target_velocity.Y - vel.Y) * PID_D * 0.833f;
+                            vec.X += (ctz.X - vel.X) * PID_D * 0.833f;
+                            vec.Y += (ctz.Y - vel.Y) * PID_D * 0.833f;
+                            // hack for  breaking on fall
+                            if (ctz.Z == -9999f)
+                                vec.Z += -vel.Z * PID_D - _parent_scene.gravityz * m_mass;
                         }
                     }
                 }
@@ -1166,9 +1299,9 @@ namespace OpenSim.Region.Physics.OdePlugin
                 vec.X -= breakfactor * vel.X;
                 vec.Y -= breakfactor * vel.Y;
                 if (flying)
-                    vec.Z -= breakfactor * vel.Z;
+                    vec.Z -= 0.5f * breakfactor * vel.Z;
                 else
-                    vec.Z -= .5f* m_mass * vel.Z;
+                    vec.Z -= .16f* m_mass * vel.Z;
             }
 
             if (flying)
@@ -1389,10 +1522,6 @@ namespace OpenSim.Region.Physics.OdePlugin
                     AvatarGeomAndBodyCreation(_position.X, _position.Y, _position.Z);
 
                     _parent_scene.actor_name_map[collider] = (PhysicsActor)this;
-//                    _parent_scene.actor_name_map[feetbox] = (PhysicsActor)this;
-//                    _parent_scene.actor_name_map[midbox] = (PhysicsActor)this;
-//                    _parent_scene.actor_name_map[topbox] = (PhysicsActor)this;
-                    _parent_scene.actor_name_map[bbox] = (PhysicsActor)this;
                     _parent_scene.actor_name_map[capsule] = (PhysicsActor)this;
                     _parent_scene.AddCharacter(this);
                 }
@@ -1449,7 +1578,6 @@ namespace OpenSim.Region.Physics.OdePlugin
                     
 
                     _parent_scene.actor_name_map[collider] = (PhysicsActor)this;
-                    _parent_scene.actor_name_map[bbox] = (PhysicsActor)this;
                     _parent_scene.actor_name_map[capsule] = (PhysicsActor)this;
                 }
                 m_freemove = false;
@@ -1553,9 +1681,9 @@ namespace OpenSim.Region.Physics.OdePlugin
             _zeroFlag = false;
             _target_velocity = Vector3.Zero;
             m_freemove = true;
-            m_colliderfilter = -2;
-            m_colliderObjectfilter = -2;
-            m_colliderGroundfilter = -2;
+            m_colliderfilter = -1;
+            m_colliderObjectfilter = -1;
+            m_colliderGroundfilter = -1;
 
             m_iscolliding = false;
             m_iscollidingGround = false;
diff --git a/OpenSim/Region/Physics/UbitOdePlugin/ODEMeshWorker.cs b/OpenSim/Region/Physics/UbitOdePlugin/ODEMeshWorker.cs
index 5030cec..a6bdaa0 100644
--- a/OpenSim/Region/Physics/UbitOdePlugin/ODEMeshWorker.cs
+++ b/OpenSim/Region/Physics/UbitOdePlugin/ODEMeshWorker.cs
@@ -100,6 +100,7 @@ namespace OpenSim.Region.Physics.OdePlugin
             }
             m_running = true;
             m_thread = new Thread(DoWork);
+            m_thread.Name = "OdeMeshWorker";
             m_thread.Start();
         }
 
diff --git a/OpenSim/Region/Physics/UbitOdePlugin/ODEPrim.cs b/OpenSim/Region/Physics/UbitOdePlugin/ODEPrim.cs
index 4cac0aa..2c3190f 100644
--- a/OpenSim/Region/Physics/UbitOdePlugin/ODEPrim.cs
+++ b/OpenSim/Region/Physics/UbitOdePlugin/ODEPrim.cs
@@ -251,8 +251,8 @@ namespace OpenSim.Region.Physics.OdePlugin
             get { return m_building; }

             set

             {

-                if (value)

-                    m_building = true;

+//                if (value)

+//                    m_building = true;

                 AddChange(changes.building, value);

             }

         }

diff --git a/OpenSim/Region/Physics/UbitOdePlugin/ODESitAvatar.cs b/OpenSim/Region/Physics/UbitOdePlugin/ODESitAvatar.cs
index e9023c3..672212f 100644
--- a/OpenSim/Region/Physics/UbitOdePlugin/ODESitAvatar.cs
+++ b/OpenSim/Region/Physics/UbitOdePlugin/ODESitAvatar.cs
@@ -78,11 +78,11 @@ namespace OpenSim.Region.Physics.OdePlugin
 
             IntPtr geom = ((OdePrim)actor).prim_geom;
 
-//            Vector3 geopos = d.GeomGetPositionOMV(geom);
-//            Quaternion geomOri = d.GeomGetQuaternionOMV(geom);
+            Vector3 geopos = d.GeomGetPositionOMV(geom);
+            Quaternion geomOri = d.GeomGetQuaternionOMV(geom);
 
-            Vector3 geopos = actor.Position;
-            Quaternion geomOri = actor.Orientation;
+//            Vector3 geopos = actor.Position;
+//            Quaternion geomOri = actor.Orientation;
 
             Quaternion geomInvOri = Quaternion.Conjugate(geomOri);
 
diff --git a/OpenSim/Region/Physics/UbitOdePlugin/OdeScene.cs b/OpenSim/Region/Physics/UbitOdePlugin/OdeScene.cs
index 8abf6cf..2adbe01 100644
--- a/OpenSim/Region/Physics/UbitOdePlugin/OdeScene.cs
+++ b/OpenSim/Region/Physics/UbitOdePlugin/OdeScene.cs
@@ -833,13 +833,7 @@ namespace OpenSim.Region.Physics.OdePlugin
                         switch (p2.PhysicsActorType)
                         {
                             case (int)ActorTypes.Agent:
-                                p1.CollidingObj = true;
-                                p2.CollidingObj = true;
-                                break;
-
                             case (int)ActorTypes.Prim:
-                                if (p2.Velocity.LengthSquared() > 0.0f)
-                                    p2.CollidingObj = true;
                                 break;
 
                             default:
@@ -850,55 +844,53 @@ namespace OpenSim.Region.Physics.OdePlugin
                     }
 
                 case (int)ActorTypes.Prim:
-                    switch (p2.PhysicsActorType)
                     {
-                        case (int)ActorTypes.Agent:
-
-                            dop2ava = true;
-
-                            if (p1.Velocity.LengthSquared() > 0.0f)
-                                p1.CollidingObj = true;
-                            break;
-
-                        case (int)ActorTypes.Prim:
-                            Vector3 relV = p1.Velocity - p2.Velocity;
-                            float relVlenSQ = relV.LengthSquared();
-                            if (relVlenSQ > 0.0001f)
-                            {
-                                p1.CollidingObj = true;
-                                p2.CollidingObj = true;
-                            }
-                            p1.getContactData(ref contactdata1);
-                            p2.getContactData(ref contactdata2);
-                            bounce = contactdata1.bounce * contactdata2.bounce;
-                            mu = (float)Math.Sqrt(contactdata1.mu * contactdata2.mu);
+                        switch (p2.PhysicsActorType)
+                        {
+                            case (int)ActorTypes.Agent:
+                                dop2ava = true;
+                                break;
 
-                            if (relVlenSQ > 0.01f)
-                                mu *= frictionMovementMult;
+                            case (int)ActorTypes.Prim:
+                                Vector3 relV = p1.Velocity - p2.Velocity;
+                                float relVlenSQ = relV.LengthSquared();
+                                if (relVlenSQ > 0.0001f)
+                                {
+                                    p1.CollidingObj = true;
+                                    p2.CollidingObj = true;
+                                }
+                                p1.getContactData(ref contactdata1);
+                                p2.getContactData(ref contactdata2);
+                                bounce = contactdata1.bounce * contactdata2.bounce;
+                                mu = (float)Math.Sqrt(contactdata1.mu * contactdata2.mu);
 
-                            break;
+                                if (relVlenSQ > 0.01f)
+                                    mu *= frictionMovementMult;
 
-                        case (int)ActorTypes.Ground:
-                            p1.getContactData(ref contactdata1);
-                            bounce = contactdata1.bounce * TerrainBounce;
-                            mu = (float)Math.Sqrt(contactdata1.mu * TerrainFriction);
+                                break;
 
-                            if (Math.Abs(p1.Velocity.X) > 0.1f || Math.Abs(p1.Velocity.Y) > 0.1f)
-                                mu *= frictionMovementMult;
-                            p1.CollidingGround = true;
-/*
-                            if (d.GeomGetClass(g1) == d.GeomClassID.TriMeshClass)
-                            {
-                                if (curContact.side1 > 0)
-                                    IgnoreNegSides = true;
-                            }
- */
-                            break;
+                            case (int)ActorTypes.Ground:
+                                p1.getContactData(ref contactdata1);
+                                bounce = contactdata1.bounce * TerrainBounce;
+                                mu = (float)Math.Sqrt(contactdata1.mu * TerrainFriction);
+
+                                if (Math.Abs(p1.Velocity.X) > 0.1f || Math.Abs(p1.Velocity.Y) > 0.1f)
+                                    mu *= frictionMovementMult;
+                                p1.CollidingGround = true;
+                                /*
+                                                            if (d.GeomGetClass(g1) == d.GeomClassID.TriMeshClass)
+                                                            {
+                                                                if (curContact.side1 > 0)
+                                                                    IgnoreNegSides = true;
+                                                            }
+                                 */
+                                break;
 
-                        case (int)ActorTypes.Water:
-                        default:
-                            ignore = true;
-                            break;
+                            case (int)ActorTypes.Water:
+                            default:
+                                ignore = true;
+                                break;
+                        }
                     }
                     break;
 
@@ -943,26 +935,55 @@ namespace OpenSim.Region.Physics.OdePlugin
             SharedTmpcontact.surface.mu = mu;
             SharedTmpcontact.surface.bounce = bounce;
 
+            d.ContactGeom altContact = new d.ContactGeom();
+            bool useAltcontact = false;
+            bool noskip = true;
+
             while (true)
             {
 //                if (!(IgnoreNegSides && curContact.side1 < 0))
                 {
-                    bool noskip = true;
+                    noskip = true;
+                    useAltcontact = false;
+
                     if (dop1ava)
                     {
-                        if (!(((OdeCharacter)p1).Collide(g1, false, ref curContact, ref FeetCollision)))
-
+                        if ((((OdeCharacter)p1).Collide(g1, g2, false, ref curContact, ref altContact , ref useAltcontact, ref FeetCollision)))
+                        {
+                            if (p2.PhysicsActorType == (int)ActorTypes.Agent)
+                            {
+                                p1.CollidingObj = true;
+                                p2.CollidingObj = true;
+                            }
+                            else if (p2.Velocity.LengthSquared() > 0.0f)
+                                    p2.CollidingObj = true;
+                        }
+                        else
                             noskip = false;
                     }
                     else if (dop2ava)
                     {
-                        if (!(((OdeCharacter)p2).Collide(g2, true, ref curContact, ref FeetCollision)))
+                        if ((((OdeCharacter)p2).Collide(g2, g1, true, ref curContact, ref altContact , ref useAltcontact, ref FeetCollision)))
+                        {
+                            if (p1.PhysicsActorType == (int)ActorTypes.Agent)
+                            {
+                                p1.CollidingObj = true;
+                                p2.CollidingObj = true;
+                            }
+                            else if (p2.Velocity.LengthSquared() > 0.0f)
+                                p1.CollidingObj = true;
+                        }
+                        else
                             noskip = false;
                     }
 
                     if (noskip)
                     {
-                        Joint = CreateContacJoint(ref curContact);
+                        if(useAltcontact)
+                            Joint = CreateContacJoint(ref altContact);
+                        else
+                            Joint = CreateContacJoint(ref curContact);
+
                         if (Joint == IntPtr.Zero)
                             break;
 
@@ -1095,10 +1116,11 @@ namespace OpenSim.Region.Physics.OdePlugin
                         // do colisions with static space
                         d.SpaceCollide2(chr.collider, StaticSpace, IntPtr.Zero, nearCallback);
 
-                        // chars with chars
-                        d.SpaceCollide(CharsSpace, IntPtr.Zero, nearCallback);
                         // no coll with gnd
                     }
+                    // chars with chars
+                    d.SpaceCollide(CharsSpace, IntPtr.Zero, nearCallback);
+
                 }
                 catch (AccessViolationException)
                 {
@@ -1920,12 +1942,12 @@ namespace OpenSim.Region.Physics.OdePlugin
                     dy = 0;
                 }
             }
-
             else
             {
                 // we  still have square fixed size regions
                 // also flip x and y because of how map is done for ODE fliped axis
                 // so ix,iy,dx and dy are inter exchanged
+
                 if (x < regsize - 1)
                 {
                     iy = (int)x;
@@ -1972,7 +1994,7 @@ namespace OpenSim.Region.Physics.OdePlugin
             */
             h0 = ((float)heights[iy]); // 0,0 vertice
 
-            if ((dy > dx))
+            if (dy>dx)
             {
                 iy += regsize;
                 h2 = (float)heights[iy]; // 0,1 vertice
@@ -1990,6 +2012,133 @@ namespace OpenSim.Region.Physics.OdePlugin
             return h0 + h1 + h2;
         }
 
+        public Vector3 GetTerrainNormalAtXY(float x, float y)
+        {
+            int offsetX = ((int)(x / (int)Constants.RegionSize)) * (int)Constants.RegionSize;
+            int offsetY = ((int)(y / (int)Constants.RegionSize)) * (int)Constants.RegionSize;
+
+            IntPtr heightFieldGeom = IntPtr.Zero;
+            Vector3 norm = new Vector3(0, 0, 1);
+
+            // get region map
+            if (!RegionTerrain.TryGetValue(new Vector3(offsetX, offsetY, 0), out heightFieldGeom))
+                return norm;
+
+            if (heightFieldGeom == IntPtr.Zero)
+                return norm;
+
+            if (!TerrainHeightFieldHeights.ContainsKey(heightFieldGeom))
+                return norm;
+
+            // TerrainHeightField for ODE as offset 1m
+            x += 1f - offsetX;
+            y += 1f - offsetY;
+
+            // make position fit into array
+            if (x < 0)
+                x = 0;
+            if (y < 0)
+                y = 0;
+
+            // integer indexs
+            int ix;
+            int iy;
+            //  interpolators offset
+            float dx;
+            float dy;
+
+
+            int regsize = (int)Constants.RegionSize + 3; // map size see setterrain number of samples
+            int xstep = 1;
+            int ystep = regsize;
+            bool firstTri = false;
+
+            if (OdeUbitLib)
+            {
+                if (x < regsize - 1)
+                {
+                    ix = (int)x;
+                    dx = x - (float)ix;
+                }
+                else // out world use external height
+                {
+                    ix = regsize - 2;
+                    dx = 0;
+                }
+                if (y < regsize - 1)
+                {
+                    iy = (int)y;
+                    dy = y - (float)iy;
+                }
+                else
+                {
+                    iy = regsize - 2;
+                    dy = 0;
+                }
+                firstTri = dy > dx;
+            }
+
+            else
+            {
+                xstep = regsize;
+                ystep = 1;
+                // we  still have square fixed size regions
+                // also flip x and y because of how map is done for ODE fliped axis
+                // so ix,iy,dx and dy are inter exchanged
+                if (x < regsize - 1)
+                {
+                    iy = (int)x;
+                    dy = x - (float)iy;
+                }
+                else // out world use external height
+                {
+                    iy = regsize - 2;
+                    dy = 0;
+                }
+                if (y < regsize - 1)
+                {
+                    ix = (int)y;
+                    dx = y - (float)ix;
+                }
+                else
+                {
+                    ix = regsize - 2;
+                    dx = 0;
+                }
+                firstTri = dx > dy;
+            }
+
+            float h0;
+            float h1;
+            float h2;
+
+            iy *= regsize;
+            iy += ix; // all indexes have iy + ix
+
+            float[] heights = TerrainHeightFieldHeights[heightFieldGeom];
+
+            if (firstTri)
+            {
+                h1 = ((float)heights[iy]); // 0,0 vertice
+                iy += ystep;
+                h0 = (float)heights[iy]; // 0,1
+                h2 = (float)heights[iy+xstep]; // 1,1 vertice
+                norm.X = h0 - h2;
+                norm.Y = h1 - h0;              
+            }
+            else
+            {
+                h2 = ((float)heights[iy]); // 0,0 vertice
+                iy += xstep;
+                h0 = ((float)heights[iy]); // 1,0 vertice
+                h1 = (float)heights[iy+ystep]; // vertice 1,1
+                norm.X = h2 - h0;
+                norm.Y = h0 - h1;
+            }
+            norm.Z = 1;
+            norm.Normalize();
+            return norm;
+        }
 
         public override void SetTerrain(float[] heightMap)
         {