44 files changed, 1297 insertions, 795 deletions

diff --git a/OpenSim/Region/PhysicsModules/BulletS/BSAPIUnman.cs b/OpenSim/Region/PhysicsModules/BulletS/BSAPIUnman.cs
index c4a923c..840e453 100644..100755
--- a/OpenSim/Region/PhysicsModules/BulletS/BSAPIUnman.cs
+++ b/OpenSim/Region/PhysicsModules/BulletS/BSAPIUnman.cs
@@ -155,8 +155,8 @@ public BSAPIUnman(string paramName, BSScene physScene)
 
 // Initialization and simulation
 public override BulletWorld Initialize(Vector3 maxPosition, ConfigurationParameters parms,
-                                                                                        int maxCollisions,  ref CollisionDesc[] collisionArray,
-                                                                                        int maxUpdates, ref EntityProperties[] updateArray
+                                            int maxCollisions,  ref CollisionDesc[] collisionArray,
+                                            int maxUpdates, ref EntityProperties[] updateArray
                                             )
 {
     // Pin down the memory that will be used to pass object collisions and updates back from unmanaged code
@@ -1405,6 +1405,19 @@ public override float GetMargin(BulletShape shape)
 }
 
 // =====================================================================================
+// Raycast
+public override SweepHit ConvexSweepTest2(BulletWorld world, BulletBody sweepObject, Vector3 from, Vector3 to, float margin) {
+    BulletWorldUnman worldu = world as BulletWorldUnman;
+    BulletBodyUnman bodyu = sweepObject as BulletBodyUnman;
+    return BSAPICPP.ConvexSweepTest2(worldu.ptr, bodyu.ptr, from, to, margin);
+}
+
+public override RaycastHit RayTest2(BulletWorld world, Vector3 from, Vector3 to, uint filterGroup, uint filterMask) {
+    BulletWorldUnman worldu = world as BulletWorldUnman;
+    return BSAPICPP.RayTest2(worldu.ptr, from, to, filterGroup, filterMask);
+}
+
+// =====================================================================================
 // Debugging
 public override void DumpRigidBody(BulletWorld world, BulletBody collisionObject)
 {
@@ -1472,8 +1485,8 @@ public delegate void DebugLogCallback([MarshalAs(UnmanagedType.LPStr)]string msg
 // Initialization and simulation
 [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
 public static extern IntPtr Initialize2(Vector3 maxPosition, IntPtr parms,
-                                                                                        int maxCollisions,  IntPtr collisionArray,
-                                                                                        int maxUpdates, IntPtr updateArray,
+                                            int maxCollisions,  IntPtr collisionArray,
+                                            int maxUpdates, IntPtr updateArray,
                                             DebugLogCallback logRoutine);
 
 [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
@@ -2084,6 +2097,15 @@ public static extern void SetMargin2(IntPtr shape, float val);
 [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
 public static extern float GetMargin2(IntPtr shape);
 
+
+// =====================================================================================
+// Raycast
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern SweepHit ConvexSweepTest2(IntPtr sim, IntPtr obj, Vector3 from, Vector3 to, float margin);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern RaycastHit RayTest2(IntPtr sim, Vector3 from, Vector3 to, uint filterGroup, uint filterMask);
+
 // =====================================================================================
 // Debugging
 [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
diff --git a/OpenSim/Region/PhysicsModules/BulletS/BSAPIXNA.cs b/OpenSim/Region/PhysicsModules/BulletS/BSAPIXNA.cs
index 887311d..7d58728 100644..100755
--- a/OpenSim/Region/PhysicsModules/BulletS/BSAPIXNA.cs
+++ b/OpenSim/Region/PhysicsModules/BulletS/BSAPIXNA.cs
@@ -815,161 +815,161 @@ private sealed class BulletConstraintXNA : BulletConstraint
     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;
-                }
+        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;
-                }
+        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;
-                }
+        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;
-                }
+        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;
     }
 
@@ -1197,20 +1197,20 @@ private sealed class BulletConstraintXNA : BulletConstraint
                                                          };
         /*
             m_mass = mass;
-                        m_motionState =motionState;
-                        m_collisionShape = collisionShape;
-                        m_localInertia = localInertia;
-                        m_linearDamping = 0f;
-                        m_angularDamping = 0f;
-                        m_friction = 0.5f;
-                        m_restitution = 0f;
-                        m_linearSleepingThreshold = 0.8f;
-                        m_angularSleepingThreshold = 1f;
-                        m_additionalDamping = false;
-                        m_additionalDampingFactor = 0.005f;
-                        m_additionalLinearDampingThresholdSqr = 0.01f;
-                        m_additionalAngularDampingThresholdSqr = 0.01f;
-                        m_additionalAngularDampingFactor = 0.01f;
+            m_motionState =motionState;
+            m_collisionShape = collisionShape;
+            m_localInertia = localInertia;
+            m_linearDamping = 0f;
+            m_angularDamping = 0f;
+            m_friction = 0.5f;
+            m_restitution = 0f;
+            m_linearSleepingThreshold = 0.8f;
+            m_angularSleepingThreshold = 1f;
+            m_additionalDamping = false;
+            m_additionalDampingFactor = 0.005f;
+            m_additionalLinearDampingThresholdSqr = 0.01f;
+            m_additionalAngularDampingThresholdSqr = 0.01f;
+            m_additionalAngularDampingFactor = 0.01f;
             m_startWorldTransform = IndexedMatrix.Identity;
         */
         body.SetUserPointer(pLocalID);
@@ -2172,7 +2172,7 @@ private sealed class BulletConstraintXNA : BulletConstraint
     }
 
     public override BulletShape CreateTerrainShape(uint id, Vector3 size, float minHeight, float maxHeight, float[] heightMap,
-                                                                float scaleFactor, float collisionMargin)
+                                float scaleFactor, float collisionMargin)
     {
         const int upAxis = 2;
         HeightfieldTerrainShape terrainShape = new HeightfieldTerrainShape((int)size.X, (int)size.Y,
@@ -2459,6 +2459,14 @@ private sealed class BulletConstraintXNA : BulletConstraint
         }
         return false;
     }
+
+    public override SweepHit ConvexSweepTest2(BulletWorld world, BulletBody obj, Vector3 from, Vector3 to, float margin) {
+        return new SweepHit();
+    }
+
+    public override RaycastHit RayTest2(BulletWorld world, Vector3 from, Vector3 to, uint filterGroup, uint filterMask) {
+        return new RaycastHit();
+    }
 }
 
 
diff --git a/OpenSim/Region/PhysicsModules/BulletS/BSActorAvatarMove.cs b/OpenSim/Region/PhysicsModules/BulletS/BSActorAvatarMove.cs
index 0191893..40c6b98 100644..100755
--- a/OpenSim/Region/PhysicsModules/BulletS/BSActorAvatarMove.cs
+++ b/OpenSim/Region/PhysicsModules/BulletS/BSActorAvatarMove.cs
@@ -47,10 +47,9 @@ public class BSActorAvatarMove : BSActor
     // 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;
+    // There are times the velocity is set but we don't want to inforce stationary until the
+    //    real velocity drops.
+    bool m_waitingForLowVelocityForStationary = false;
 
     public BSActorAvatarMove(BSScene physicsScene, BSPhysObject pObj, string actorName)
         : base(physicsScene, pObj, actorName)
@@ -109,19 +108,23 @@ public class BSActorAvatarMove : BSActor
         {
             if (m_velocityMotor != null)
             {
-//                    if (targ == OMV.Vector3.Zero)
-//                        Util.PrintCallStack();
-//
-//                    Console.WriteLine("SetVelocityAndTarget, {0} {1}", vel, targ);
                 m_velocityMotor.Reset();
                 m_velocityMotor.SetTarget(targ);
                 m_velocityMotor.SetCurrent(vel);
                 m_velocityMotor.Enabled = true;
+                m_physicsScene.DetailLog("{0},BSCharacter.MoveMotor,SetVelocityAndTarget,vel={1}, targ={2}",
+                            m_controllingPrim.LocalID, vel, targ);
+                m_waitingForLowVelocityForStationary = false;
             }
         });
     }
 
-    // If a hover motor has not been created, create one and start the hovering.
+    public void SuppressStationayCheckUntilLowVelocity()
+    {
+        m_waitingForLowVelocityForStationary = true;
+    }
+
+    // If a movement motor has not been created, create one and start the movement
     private void ActivateAvatarMove()
     {
         if (m_velocityMotor == null)
@@ -133,13 +136,14 @@ public class BSActorAvatarMove : BSActor
                                                 1f                          // efficiency
             );
             m_velocityMotor.ErrorZeroThreshold = BSParam.AvatarStopZeroThreshold;
-            // _velocityMotor.PhysicsScene = PhysicsScene; // DEBUG DEBUG so motor will output detail log messages.
+            // m_velocityMotor.PhysicsScene = m_controllingPrim.PhysScene; // 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;
+            m_waitingForLowVelocityForStationary = false;
         }
     }
 
@@ -153,7 +157,7 @@ public class BSActorAvatarMove : BSActor
         }
     }
 
-    // Called just before the simulation step. Update the vertical position for hoverness.
+    // Called just before the simulation step.
     private void Mover(float timeStep)
     {
         // Don't do movement while the object is selected.
@@ -187,12 +191,28 @@ public class BSActorAvatarMove : BSActor
 
             if (m_controllingPrim.IsColliding)
             {
-                // If we are colliding with a stationary object, presume we're standing and don't move around
+                // if colliding with something stationary and we're not doing volume detect .
                 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 */);
+                    if (m_waitingForLowVelocityForStationary)
+                    {
+                        // if waiting for velocity to drop and it has finally dropped, we can be stationary
+                        if (m_controllingPrim.RawVelocity.LengthSquared() < BSParam.AvatarStopZeroThresholdSquared)
+                        {
+                            m_waitingForLowVelocityForStationary = false;
+                        }
+                    }
+                    if (!m_waitingForLowVelocityForStationary)
+                    {
+                        m_physicsScene.DetailLog("{0},BSCharacter.MoveMotor,collidingWithStationary,zeroingMotion", m_controllingPrim.LocalID);
+                        m_controllingPrim.IsStationary = true;
+                        m_controllingPrim.ZeroMotion(true /* inTaintTime */);
+                    }
+                    else
+                    {
+                        m_physicsScene.DetailLog("{0},BSCharacter.MoveMotor,waitingForLowVel,rawvel={1}",
+                                    m_controllingPrim.LocalID, m_controllingPrim.RawVelocity.Length());
+                    }
                 }
 
                 // Standing has more friction on the ground
@@ -222,8 +242,8 @@ public class BSActorAvatarMove : BSActor
                 }
             }
 
-            m_physicsScene.DetailLog("{0},BSCharacter.MoveMotor,taint,stopping,target={1},colliding={2}",
-                            m_controllingPrim.LocalID, m_velocityMotor.TargetValue, m_controllingPrim.IsColliding);
+            m_physicsScene.DetailLog("{0},BSCharacter.MoveMotor,taint,stopping,target={1},colliding={2},isStationary={3}",
+                            m_controllingPrim.LocalID, m_velocityMotor.TargetValue, m_controllingPrim.IsColliding,m_controllingPrim.IsStationary);
         }
         else
         {
@@ -237,50 +257,24 @@ public class BSActorAvatarMove : BSActor
                 m_physicsScene.PE.SetFriction(m_controllingPrim.PhysBody, m_controllingPrim.Friction);
             }
 
-            if (!m_controllingPrim.Flying && !m_controllingPrim.IsColliding)
-            {
-                stepVelocity.Z = m_controllingPrim.RawVelocity.Z;
-            }
+            // 'm_velocityMotor is used for walking, flying, and jumping and will thus have the correct values
+            //    for Z. But in come cases it must be over-ridden. Like when falling or jumping.
 
-            // 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;
-            }
+            float realVelocityZ = m_controllingPrim.RawVelocity.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 not flying and falling, we over-ride the stepping motor so we can fall to the ground
+            if (!m_controllingPrim.Flying && realVelocityZ < 0)
             {
-                // If upward velocity is being applied, this must be a jump and only allow that to go on so long
-                if (m_jumpFrames > 0)
+                // Can't fall faster than this
+                if (realVelocityZ < BSParam.AvatarTerminalVelocity)
                 {
-                    // Since not touching the ground, only apply upward force for so long.
-                    m_jumpFrames--;
-                    stepVelocity.Z = m_jumpVelocity;
+                    realVelocityZ = BSParam.AvatarTerminalVelocity;
                 }
-                else
-                {
-                    
-                    // Since we're not affected by anything, the avatar must be falling and we do not want that to be too fast.
-                    if (m_controllingPrim.RawVelocity.Z < BSParam.AvatarTerminalVelocity)
-                    {
-                        
-                        stepVelocity.Z = BSParam.AvatarTerminalVelocity;
-                    }
-                    else
-                    {
-                        stepVelocity.Z = m_controllingPrim.RawVelocity.Z;
-                    }
-                }
-                // DetailLog("{0},BSCharacter.MoveMotor,taint,overrideStepZWithWorldZ,stepVel={1}", LocalID, stepVelocity);
+
+                stepVelocity.Z = realVelocityZ;
             }
+            // m_physicsScene.DetailLog("{0},BSCharacter.MoveMotor,DEBUG,motorCurrent={1},realZ={2},flying={3},collid={4},jFrames={5}",
+            //     m_controllingPrim.LocalID, m_velocityMotor.CurrentValue, realVelocityZ, m_controllingPrim.Flying, m_controllingPrim.IsColliding, m_jumpFrames);
 
             //Alicia: Maintain minimum height when flying.
             // SL has a flying effect that keeps the avatar flying above the ground by some margin
@@ -291,6 +285,8 @@ public class BSActorAvatarMove : BSActor
 
                 if( m_controllingPrim.Position.Z < hover_height)
                 {
+                    m_physicsScene.DetailLog("{0},BSCharacter.MoveMotor,addingUpforceForGroundMargin,height={1},hoverHeight={2}",
+                                m_controllingPrim.LocalID, m_controllingPrim.Position.Z, hover_height);
                     stepVelocity.Z += BSParam.AvatarFlyingGroundUpForce;
                 }
             }
diff --git a/OpenSim/Region/PhysicsModules/BulletS/BSActorHover.cs b/OpenSim/Region/PhysicsModules/BulletS/BSActorHover.cs
index 7ff171e..7ff171e 100644..100755
--- a/OpenSim/Region/PhysicsModules/BulletS/BSActorHover.cs
+++ b/OpenSim/Region/PhysicsModules/BulletS/BSActorHover.cs
diff --git a/OpenSim/Region/PhysicsModules/BulletS/BSActorLockAxis.cs b/OpenSim/Region/PhysicsModules/BulletS/BSActorLockAxis.cs
index 78c1b6a..78c1b6a 100644..100755
--- a/OpenSim/Region/PhysicsModules/BulletS/BSActorLockAxis.cs
+++ b/OpenSim/Region/PhysicsModules/BulletS/BSActorLockAxis.cs
diff --git a/OpenSim/Region/PhysicsModules/BulletS/BSActorMoveToTarget.cs b/OpenSim/Region/PhysicsModules/BulletS/BSActorMoveToTarget.cs
index 3db8f2c..f2019ae 100644..100755
--- a/OpenSim/Region/PhysicsModules/BulletS/BSActorMoveToTarget.cs
+++ b/OpenSim/Region/PhysicsModules/BulletS/BSActorMoveToTarget.cs
@@ -205,13 +205,13 @@ public class BSActorMoveToTarget : BSActor
             addedForce = correctionVector / timeStep;
             // Remove the existing velocity (only the moveToTarget force counts)
             addedForce -= m_controllingPrim.RawVelocity;
-            // Overcome gravity. 
+            // 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_controllingPrim.AddForce(true /* inTaintTime */, addedForce);
         }
         m_physicsScene.DetailLog("{0},BSActorMoveToTarget.Mover3,move,fromPos={1},addedForce={2}",
                                         m_controllingPrim.LocalID, origPosition, addedForce);
diff --git a/OpenSim/Region/PhysicsModules/BulletS/BSActorSetForce.cs b/OpenSim/Region/PhysicsModules/BulletS/BSActorSetForce.cs
index ecb4b7f..ecb4b7f 100644..100755
--- a/OpenSim/Region/PhysicsModules/BulletS/BSActorSetForce.cs
+++ b/OpenSim/Region/PhysicsModules/BulletS/BSActorSetForce.cs
diff --git a/OpenSim/Region/PhysicsModules/BulletS/BSActorSetTorque.cs b/OpenSim/Region/PhysicsModules/BulletS/BSActorSetTorque.cs
index a1cf4db..0261bcb 100644..100755
--- a/OpenSim/Region/PhysicsModules/BulletS/BSActorSetTorque.cs
+++ b/OpenSim/Region/PhysicsModules/BulletS/BSActorSetTorque.cs
@@ -127,7 +127,7 @@ public class BSActorSetTorque : BSActor
         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.AddAngularForce(true /* inTaintTime */, m_controllingPrim.RawTorque);
             m_controllingPrim.ActivateIfPhysical(false);
         }
 
diff --git a/OpenSim/Region/PhysicsModules/BulletS/BSActors.cs b/OpenSim/Region/PhysicsModules/BulletS/BSActors.cs
index 851347b..851347b 100644..100755
--- a/OpenSim/Region/PhysicsModules/BulletS/BSActors.cs
+++ b/OpenSim/Region/PhysicsModules/BulletS/BSActors.cs
diff --git a/OpenSim/Region/PhysicsModules/BulletS/BSApiTemplate.cs b/OpenSim/Region/PhysicsModules/BulletS/BSApiTemplate.cs
index 7756b10..a288048 100644
--- a/OpenSim/Region/PhysicsModules/BulletS/BSApiTemplate.cs
+++ b/OpenSim/Region/PhysicsModules/BulletS/BSApiTemplate.cs
@@ -36,16 +36,16 @@ namespace OpenSim.Region.PhysicsModule.BulletS {
     // Constraint type values as defined by Bullet
 public enum ConstraintType : int
 {
-        POINT2POINT_CONSTRAINT_TYPE = 3,
-        HINGE_CONSTRAINT_TYPE,
-        CONETWIST_CONSTRAINT_TYPE,
-        D6_CONSTRAINT_TYPE,
-        SLIDER_CONSTRAINT_TYPE,
-        CONTACT_CONSTRAINT_TYPE,
-        D6_SPRING_CONSTRAINT_TYPE,
-        GEAR_CONSTRAINT_TYPE,           // added in Bullet 2.82
-        FIXED_CONSTRAINT_TYPE,          // added in Bullet 2.82
-        MAX_CONSTRAINT_TYPE,            // last type defined by Bullet
+    POINT2POINT_CONSTRAINT_TYPE = 3,
+    HINGE_CONSTRAINT_TYPE,
+    CONETWIST_CONSTRAINT_TYPE,
+    D6_CONSTRAINT_TYPE,
+    SLIDER_CONSTRAINT_TYPE,
+    CONTACT_CONSTRAINT_TYPE,
+    D6_SPRING_CONSTRAINT_TYPE,
+    GEAR_CONSTRAINT_TYPE,           // added in Bullet 2.82
+    FIXED_CONSTRAINT_TYPE,          // added in Bullet 2.82
+    MAX_CONSTRAINT_TYPE,            // last type defined by Bullet
     //
     BS_FIXED_CONSTRAINT_TYPE = 1234    // BulletSim constraint that is fixed and unmoving
 }
@@ -54,25 +54,25 @@ public enum ConstraintType : int
 [StructLayout(LayoutKind.Sequential)]
 public struct ConvexHull
 {
-        Vector3 Offset;
-        int VertexCount;
-        Vector3[] Vertices;
+    Vector3 Offset;
+    int VertexCount;
+    Vector3[] Vertices;
 }
 public enum BSPhysicsShapeType
 {
-        SHAPE_UNKNOWN   = 0,
-        SHAPE_CAPSULE   = 1,
-        SHAPE_BOX       = 2,
-        SHAPE_CONE      = 3,
-        SHAPE_CYLINDER  = 4,
-        SHAPE_SPHERE    = 5,
-        SHAPE_MESH      = 6,
-        SHAPE_HULL      = 7,
+    SHAPE_UNKNOWN   = 0,
+    SHAPE_CAPSULE   = 1,
+    SHAPE_BOX       = 2,
+    SHAPE_CONE      = 3,
+    SHAPE_CYLINDER  = 4,
+    SHAPE_SPHERE    = 5,
+    SHAPE_MESH      = 6,
+    SHAPE_HULL      = 7,
     // following defined by BulletSim
-        SHAPE_GROUNDPLANE  = 20,
-        SHAPE_TERRAIN   = 21,
-        SHAPE_COMPOUND  = 22,
-        SHAPE_HEIGHTMAP = 23,
+    SHAPE_GROUNDPLANE  = 20,
+    SHAPE_TERRAIN   = 21,
+    SHAPE_COMPOUND  = 22,
+    SHAPE_HEIGHTMAP = 23,
     SHAPE_AVATAR    = 24,
     SHAPE_CONVEXHULL= 25,
     SHAPE_GIMPACT   = 26,
@@ -121,6 +121,14 @@ public struct SweepHit
     public float Fraction;
     public Vector3 Normal;
     public Vector3 Point;
+
+    public bool hasHit()
+    {
+        float sum = Fraction
+                + Normal.X + Normal.Y + Normal.Z
+                + Point.X + Point.Y + Point.Z;
+        return (sum != 0) || (ID != 0);
+    }
 }
 [StructLayout(LayoutKind.Sequential)]
 public struct RaycastHit
@@ -128,6 +136,13 @@ public struct RaycastHit
     public UInt32 ID;
     public float Fraction;
     public Vector3 Normal;
+    public Vector3 Point;
+
+    public bool hasHit()
+    {
+        float sum = Normal.X + Normal.Y + Normal.Z + Point.X + Point.Y + Point.Z;
+        return (sum != 0);
+    }
 }
 [StructLayout(LayoutKind.Sequential)]
 public struct CollisionDesc
@@ -180,16 +195,16 @@ public struct ConfigurationParameters
     public float collisionMargin;
     public float gravity;
 
-        public float maxPersistantManifoldPoolSize;
-        public float maxCollisionAlgorithmPoolSize;
-        public float shouldDisableContactPoolDynamicAllocation;
-        public float shouldForceUpdateAllAabbs;
-        public float shouldRandomizeSolverOrder;
-        public float shouldSplitSimulationIslands;
-        public float shouldEnableFrictionCaching;
-        public float numberOfSolverIterations;
+    public float maxPersistantManifoldPoolSize;
+    public float maxCollisionAlgorithmPoolSize;
+    public float shouldDisableContactPoolDynamicAllocation;
+    public float shouldForceUpdateAllAabbs;
+    public float shouldRandomizeSolverOrder;
+    public float shouldSplitSimulationIslands;
+    public float shouldEnableFrictionCaching;
+    public float numberOfSolverIterations;
     public float useSingleSidedMeshes;
-        public float globalContactBreakingThreshold;
+    public float globalContactBreakingThreshold;
 
     public float physicsLoggingFrames;
 
@@ -202,30 +217,30 @@ public struct ConfigurationParameters
 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
+    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
     // VHACD
-        public float whichHACD;                             // zero if Bullet HACD, non-zero says VHACD
-        // http://kmamou.blogspot.ca/2014/12/v-hacd-20-parameters-description.html
-        public float vHACDresolution;                   // 100,000 max number of voxels generated during voxelization stage
-        public float vHACDdepth;                                // 20 max number of clipping stages
-        public float vHACDconcavity;                    // 0.0025 maximum concavity
-        public float vHACDplaneDownsampling;    // 4 granularity of search for best clipping plane
-        public float vHACDconvexHullDownsampling;       // 4 precision of hull gen process
-        public float vHACDalpha;                                // 0.05 bias toward clipping along symmetry planes
-        public float vHACDbeta;                             // 0.05 bias toward clipping along revolution axis
-        public float vHACDgamma;                                // 0.00125 max concavity when merging
-        public float vHACDpca;                                  // 0 on/off normalizing mesh before decomp
-        public float vHACDmode;                             // 0 0:voxel based, 1: tetrahedron based
-        public float vHACDmaxNumVerticesPerCH;  // 64 max triangles per convex hull
-        public float vHACDminVolumePerCH;               // 0.0001 sampling of generated convex hulls
+    public float whichHACD;                                 // zero if Bullet HACD, non-zero says VHACD
+    // http://kmamou.blogspot.ca/2014/12/v-hacd-20-parameters-description.html
+    public float vHACDresolution;                       // 100,000 max number of voxels generated during voxelization stage
+    public float vHACDdepth;                            // 20 max number of clipping stages
+    public float vHACDconcavity;                        // 0.0025 maximum concavity
+    public float vHACDplaneDownsampling;        // 4 granularity of search for best clipping plane
+    public float vHACDconvexHullDownsampling;   // 4 precision of hull gen process
+    public float vHACDalpha;                            // 0.05 bias toward clipping along symmetry planes
+    public float vHACDbeta;                                 // 0.05 bias toward clipping along revolution axis
+    public float vHACDgamma;                            // 0.00125 max concavity when merging
+    public float vHACDpca;                                      // 0 on/off normalizing mesh before decomp
+    public float vHACDmode;                                 // 0 0:voxel based, 1: tetrahedron based
+    public float vHACDmaxNumVerticesPerCH;      // 64 max triangles per convex hull
+    public float vHACDminVolumePerCH;           // 0.0001 sampling of generated convex hulls
 }
 
 // The states a bullet collision object can have
@@ -322,8 +337,8 @@ public abstract string BulletEngineVersion { get; protected set;}
 
 // Initialization and simulation
 public abstract BulletWorld Initialize(Vector3 maxPosition, ConfigurationParameters parms,
-                                                                                        int maxCollisions,  ref CollisionDesc[] collisionArray,
-                                                                                        int maxUpdates, ref EntityProperties[] updateArray
+                                            int maxCollisions,  ref CollisionDesc[] collisionArray,
+                                            int maxUpdates, ref EntityProperties[] updateArray
                                             );
 
 public abstract int PhysicsStep(BulletWorld world, float timeStep, int maxSubSteps, float fixedTimeStep,
@@ -398,7 +413,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,
-                                                                float scaleFactor, float collisionMargin);
+                                float scaleFactor, float collisionMargin);
 
 // =====================================================================================
 // Constraint creation and helper routines
@@ -742,6 +757,12 @@ public abstract void SetMargin(BulletShape shape, float val);
 public abstract float GetMargin(BulletShape shape);
 
 // =====================================================================================
+// Raycast
+public abstract SweepHit ConvexSweepTest2(BulletWorld world, BulletBody obj, Vector3 from, Vector3 to, float margin);
+
+public abstract RaycastHit RayTest2(BulletWorld world, Vector3 from, Vector3 to, uint filterGroup, uint filterMask);
+
+// =====================================================================================
 // Debugging
 public virtual void DumpRigidBody(BulletWorld sim, BulletBody collisionObject) { }
 
diff --git a/OpenSim/Region/PhysicsModules/BulletS/BSCharacter.cs b/OpenSim/Region/PhysicsModules/BulletS/BSCharacter.cs
index 83fc3a6..d182c34 100644
--- a/OpenSim/Region/PhysicsModules/BulletS/BSCharacter.cs
+++ b/OpenSim/Region/PhysicsModules/BulletS/BSCharacter.cs
@@ -40,7 +40,6 @@ public sealed class BSCharacter : BSPhysObject
     private static readonly string LogHeader = "[BULLETS CHAR]";
 
     // private bool _stopped;
-    private OMV.Vector3 _size;
     private bool _grabbed;
     private bool _selected;
     private float _mass;
@@ -53,19 +52,21 @@ public sealed class BSCharacter : BSPhysObject
     private bool _setAlwaysRun;
     private bool _throttleUpdates;
     private bool _floatOnWater;
-    private OMV.Vector3 _rotationalVelocity;
     private bool _kinematic;
     private float _buoyancy;
 
+    private OMV.Vector3 _size;
+    private float _footOffset;
+
     private BSActorAvatarMove m_moveActor;
     private const string AvatarMoveActorName = "BSCharacter.AvatarMove";
 
     private OMV.Vector3 _PIDTarget;
     private float _PIDTau;
 
-//        public override OMV.Vector3 RawVelocity 
-//        { get { return base.RawVelocity; } 
-//            set { 
+//        public override OMV.Vector3 RawVelocity
+//        { get { return base.RawVelocity; }
+//            set {
 //                if (value != base.RawVelocity)
 //                    Util.PrintCallStack();
 //                Console.WriteLine("Set rawvel to {0}", value);
@@ -76,12 +77,12 @@ public sealed class BSCharacter : BSPhysObject
     public override bool IsIncomplete { get { return false; } }
 
     public BSCharacter(
-            uint localID, String avName, BSScene parent_scene, OMV.Vector3 pos, OMV.Vector3 vel, OMV.Vector3 size, bool isFlying)
+            uint localID, String avName, BSScene parent_scene, OMV.Vector3 pos, OMV.Vector3 vel, OMV.Vector3 size, float footOffset, bool isFlying)
 
             : base(parent_scene, localID, avName, "BSCharacter")
     {
         _physicsActorType = (int)ActorTypes.Agent;
-        RawPosition = pos;        
+        RawPosition = pos;
 
         _flying = isFlying;
         RawOrientation = OMV.Quaternion.Identity;
@@ -89,22 +90,15 @@ public sealed class BSCharacter : BSPhysObject
         _buoyancy = ComputeBuoyancyFromFlying(isFlying);
         Friction = BSParam.AvatarStandingFriction;
         Density = BSParam.AvatarDensity;
+        _isPhysical = true;
 
-        // Old versions of ScenePresence passed only the height. If width and/or depth are zero,
-        //     replace with the default values.
-        _size = size;
-        if (_size.X == 0f) _size.X = BSParam.AvatarCapsuleDepth;
-        if (_size.Y == 0f) _size.Y = BSParam.AvatarCapsuleWidth;
-
-        // The dimensions of the physical capsule are kept in the scale.
-        // Physics creates a unit capsule which is scaled by the physics engine.
-        Scale = ComputeAvatarScale(_size);
-        // set _avatarVolume and _mass based on capsule size, _density and Scale
-        ComputeAvatarVolumeAndMass();
+        // Adjustments for zero X and Y made in Size()
+        // This also computes avatar scale, volume, and mass
+        SetAvatarSize(size, footOffset, true /* initializing */);
 
         DetailLog(
             "{0},BSCharacter.create,call,size={1},scale={2},density={3},volume={4},mass={5},pos={6},vel={7}",
-            LocalID, _size, Scale, Density, _avatarVolume, RawMass, pos, vel);
+            LocalID, Size, Scale, Density, _avatarVolume, RawMass, pos, vel);
 
         // do actual creation in taint time
         PhysScene.TaintedObject(LocalID, "BSCharacter.create", delegate()
@@ -208,45 +202,68 @@ public sealed class BSCharacter : BSPhysObject
     public override OMV.Vector3 Size {
         get
         {
-            // Avatar capsule size is kept in the scale parameter.
             return _size;
         }
 
         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;
+            setAvatarSize(value, _footOffset);
+        }
+    }
+
+    // OpenSim 0.9 introduces a common avatar size computation
+    public override void setAvatarSize(OMV.Vector3 size, float feetOffset)
+    {
+        SetAvatarSize(size, feetOffset, false /* initializing */);
+    }
 
-            _size = value;
+    // Internal version that, if initializing, doesn't do all the updating of the physics engine
+    public void SetAvatarSize(OMV.Vector3 size, float feetOffset, bool initializing)
+    {
+        OMV.Vector3 newSize = size;
+        if (newSize.IsFinite())
+        {
             // Old versions of ScenePresence passed only the height. If width and/or depth are zero,
             //     replace with the default values.
-            if (_size.X == 0f) _size.X = BSParam.AvatarCapsuleDepth;
-            if (_size.Y == 0f) _size.Y = BSParam.AvatarCapsuleWidth;
+            if (newSize.X == 0f) newSize.X = BSParam.AvatarCapsuleDepth;
+            if (newSize.Y == 0f) newSize.Y = BSParam.AvatarCapsuleWidth;
 
-            Scale = ComputeAvatarScale(_size);
-            ComputeAvatarVolumeAndMass();
-            DetailLog("{0},BSCharacter.setSize,call,size={1},scale={2},density={3},volume={4},mass={5}",
-                            LocalID, _size, Scale, Density, _avatarVolume, RawMass);
+            if (newSize.X < 0.01f) newSize.X = 0.01f;
+            if (newSize.Y < 0.01f) newSize.Y = 0.01f;
+            if (newSize.Z < 0.01f) newSize.Z = BSParam.AvatarCapsuleHeight;
+        }
+        else
+        {
+            newSize = new OMV.Vector3(BSParam.AvatarCapsuleDepth, BSParam.AvatarCapsuleWidth, BSParam.AvatarCapsuleHeight);
+        }
 
-            PhysScene.TaintedObject(LocalID, "BSCharacter.setSize", delegate()
-            {
-                if (PhysBody.HasPhysicalBody && PhysShape.physShapeInfo.HasPhysicalShape)
-                {
-                    PhysScene.PE.SetLocalScaling(PhysShape.physShapeInfo, Scale);
-                    UpdatePhysicalMassProperties(RawMass, true);
+        // This is how much the avatar size is changing. Positive means getting bigger.
+        // The avatar altitude must be adjusted for this change.
+        float heightChange = newSize.Z - Size.Z;
 
-                    // 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);
+        _size = newSize;
 
-                    // Make sure this change appears as a property update event
-                    PhysScene.PE.PushUpdate(PhysBody);
-                }
-            });
+        Scale = ComputeAvatarScale(Size);
+        ComputeAvatarVolumeAndMass();
+        DetailLog("{0},BSCharacter.setSize,call,size={1},scale={2},density={3},volume={4},mass={5}",
+                        LocalID, _size, Scale, Density, _avatarVolume, RawMass);
 
-        }
+        PhysScene.TaintedObject(LocalID, "BSCharacter.setSize", delegate()
+        {
+            if (PhysBody.HasPhysicalBody && PhysShape.physShapeInfo.HasPhysicalShape)
+            {
+                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
+                PhysScene.PE.PushUpdate(PhysBody);
+            }
+        });
     }
 
-    public override PrimitiveBaseShape Shape
+        public override PrimitiveBaseShape Shape
     {
         set { BaseShape = value; }
     }
@@ -273,7 +290,7 @@ public sealed class BSCharacter : BSPhysObject
     {
         RawVelocity = OMV.Vector3.Zero;
         _acceleration = OMV.Vector3.Zero;
-        _rotationalVelocity = OMV.Vector3.Zero;
+        RawRotationalVelocity = OMV.Vector3.Zero;
 
         // Zero some other properties directly into the physics engine
         PhysScene.TaintedObject(inTaintTime, LocalID, "BSCharacter.ZeroMotion", delegate()
@@ -285,7 +302,7 @@ public sealed class BSCharacter : BSPhysObject
 
     public override void ZeroAngularMotion(bool inTaintTime)
     {
-        _rotationalVelocity = OMV.Vector3.Zero;
+        RawRotationalVelocity = OMV.Vector3.Zero;
 
         PhysScene.TaintedObject(inTaintTime, LocalID, "BSCharacter.ZeroMotion", delegate()
         {
@@ -300,7 +317,7 @@ public sealed class BSCharacter : BSPhysObject
     }
 
 
-    public override void LockAngularMotion(OMV.Vector3 axis) { return; }
+    public override void LockAngularMotion(byte axislocks) { return; }
 
     public override OMV.Vector3 Position {
         get {
@@ -333,7 +350,6 @@ public sealed class BSCharacter : BSPhysObject
         }
     }
 
-
     // Check that the current position is sane and, if not, modify the position to make it so.
     // Check for being below terrain or on water.
     // Returns 'true' of the position was made sane by some action.
@@ -433,6 +449,7 @@ public sealed class BSCharacter : BSPhysObject
     public override OMV.Vector3 GeometricCenter { get { return OMV.Vector3.Zero; } }
     public override OMV.Vector3 CenterOfMass { get { return OMV.Vector3.Zero; } }
 
+    // PhysicsActor.TargetVelocity
     // Sets the target in the motor. This starts the changing of the avatar's velocity.
     public override OMV.Vector3 TargetVelocity
     {
@@ -443,43 +460,51 @@ public sealed class BSCharacter : BSPhysObject
         set
         {
             DetailLog("{0},BSCharacter.setTargetVelocity,call,vel={1}", LocalID, value);
-            m_targetVelocity = value;
             OMV.Vector3 targetVel = value;
-            if (_setAlwaysRun && !_flying)
-                targetVel *= new OMV.Vector3(BSParam.AvatarAlwaysRunFactor, BSParam.AvatarAlwaysRunFactor, 1f);
+            if (!_flying)
+            {
+                if (_setAlwaysRun)
+                    targetVel *= new OMV.Vector3(BSParam.AvatarAlwaysRunFactor, BSParam.AvatarAlwaysRunFactor, 1f);
+                else
+                    if (BSParam.AvatarWalkVelocityFactor != 1f)
+                        targetVel *= new OMV.Vector3(BSParam.AvatarWalkVelocityFactor, BSParam.AvatarWalkVelocityFactor, 1f);
+            }
+            base.m_targetVelocity = targetVel;
 
             if (m_moveActor != null)
-                m_moveActor.SetVelocityAndTarget(RawVelocity, targetVel, false /* inTaintTime */);
+                m_moveActor.SetVelocityAndTarget(RawVelocity, base.m_targetVelocity, false /* inTaintTime */);
         }
     }
     // Directly setting velocity means this is what the user really wants now.
     public override OMV.Vector3 Velocity {
         get { return RawVelocity; }
         set {
-            RawVelocity = value;
-                OMV.Vector3 vel = RawVelocity;
-
-            DetailLog("{0}: set Velocity = {1}", LocalID, value);
-
-            PhysScene.TaintedObject(LocalID, "BSCharacter.setVelocity", delegate()
+            if (m_moveActor != null)
             {
-                if (m_moveActor != null)
-                    m_moveActor.SetVelocityAndTarget(vel, vel, true /* inTaintTime */);
+                // m_moveActor.SetVelocityAndTarget(OMV.Vector3.Zero, OMV.Vector3.Zero, false /* inTaintTime */);
+                m_moveActor.SetVelocityAndTarget(RawVelocity, RawVelocity, false /* inTaintTime */);
+            }
+            base.Velocity = value;
+        }
+    }
 
-                DetailLog("{0},BSCharacter.setVelocity,taint,vel={1}", LocalID, vel);
-                ForceVelocity = vel;
-            });
+    // SetMomentum just sets the velocity without a target. We need to stop the movement actor if a character.
+    public override void SetMomentum(OMV.Vector3 momentum)
+    {
+        if (m_moveActor != null)
+        {
+            // m_moveActor.SetVelocityAndTarget(OMV.Vector3.Zero, OMV.Vector3.Zero, false /* inTaintTime */);
+            m_moveActor.SetVelocityAndTarget(RawVelocity, RawVelocity, false /* inTaintTime */);
         }
+        base.SetMomentum(momentum);
     }
 
     public override OMV.Vector3 ForceVelocity {
         get { return RawVelocity; }
         set {
-            PhysScene.AssertInTaintTime("BSCharacter.ForceVelocity");
-//                Util.PrintCallStack();
-            DetailLog("{0}: set ForceVelocity = {1}", LocalID, value);
+            DetailLog("{0},BSCharacter.ForceVelocity.set={1}", LocalID, value);
 
-            RawVelocity = value;
+            RawVelocity = Util.ClampV(value, BSParam.MaxLinearVelocity);
             PhysScene.PE.SetLinearVelocity(PhysBody, RawVelocity);
             PhysScene.PE.Activate(PhysBody, true);
         }
@@ -600,14 +625,6 @@ public sealed class BSCharacter : BSPhysObject
             });
         }
     }
-    public override OMV.Vector3 RotationalVelocity {
-        get { return _rotationalVelocity; }
-        set { _rotationalVelocity = value; }
-    }
-    public override OMV.Vector3 ForceRotationalVelocity {
-        get { return _rotationalVelocity; }
-        set { _rotationalVelocity = value; }
-    }
     public override bool Kinematic {
         get { return _kinematic; }
         set { _kinematic = value; }
@@ -626,8 +643,6 @@ public sealed class BSCharacter : BSPhysObject
     public override float ForceBuoyancy {
         get { return _buoyancy; }
         set {
-            PhysScene.AssertInTaintTime("BSCharacter.ForceBuoyancy");
-
             _buoyancy = value;
             DetailLog("{0},BSCharacter.setForceBuoyancy,taint,buoy={1}", LocalID, _buoyancy);
             // Buoyancy is faked by changing the gravity applied to the object
@@ -652,14 +667,24 @@ public sealed class BSCharacter : BSPhysObject
     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 / PhysScene.LastTimeStep;
-        AddForce(addForce, pushforce, false);
+        OMV.Vector3 addForce = force;
+
+        // The interaction of this force with the simulator rate and collision occurance is tricky.
+        // ODE multiplies the force by 100
+        // ubODE multiplies the force by 5.3
+        // BulletSim, after much in-world testing, thinks it gets a similar effect by multiplying mass*0.315f
+        //    This number could be a feature of friction or timing, but it seems to move avatars the same as ubODE
+        addForce *= Mass * BSParam.AvatarAddForcePushFactor;
+
+        DetailLog("{0},BSCharacter.addForce,call,force={1},addForce={2},push={3},mass={4}", LocalID, force, addForce, pushforce, Mass);
+        AddForce(false, addForce);
     }
-    public override void AddForce(OMV.Vector3 force, bool pushforce, bool inTaintTime) {
+
+    public override void AddForce(bool inTaintTime, OMV.Vector3 force) {
         if (force.IsFinite())
         {
             OMV.Vector3 addForce = Util.ClampV(force, BSParam.MaxAddForceMagnitude);
-            // DetailLog("{0},BSCharacter.addForce,call,force={1}", LocalID, addForce);
+            // DetailLog("{0},BSCharacter.addForce,call,force={1},push={2},inTaint={3}", LocalID, addForce, pushforce, inTaintTime);
 
             PhysScene.TaintedObject(inTaintTime, LocalID, "BSCharacter.AddForce", delegate()
             {
@@ -667,7 +692,15 @@ public sealed class BSCharacter : BSPhysObject
                 // DetailLog("{0},BSCharacter.addForce,taint,force={1}", LocalID, addForce);
                 if (PhysBody.HasPhysicalBody)
                 {
+                    // Bullet adds this central force to the total force for this tick.
+                    // Deep down in Bullet:
+                    //      linearVelocity += totalForce / mass * timeStep;
                     PhysScene.PE.ApplyCentralForce(PhysBody, addForce);
+                    PhysScene.PE.Activate(PhysBody, true);
+                }
+                if (m_moveActor != null)
+                {
+                    m_moveActor.SuppressStationayCheckUntilLowVelocity();
                 }
             });
         }
@@ -678,65 +711,74 @@ public sealed class BSCharacter : BSPhysObject
         }
     }
 
-    public override void AddAngularForce(OMV.Vector3 force, bool pushforce, bool inTaintTime) {
-    }
-    public override void SetMomentum(OMV.Vector3 momentum) {
+    public override void AddAngularForce(bool inTaintTime, OMV.Vector3 force) {
     }
 
+    // The avatar's physical shape (whether capsule or cube) is unit sized. BulletSim sets
+    //    the scale of that unit shape to create the avatars full size.
     private OMV.Vector3 ComputeAvatarScale(OMV.Vector3 size)
     {
         OMV.Vector3 newScale = size;
 
-        // Bullet's capsule total height is the "passed height + radius * 2";
-        // 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.
-        // 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.
+        if (BSParam.AvatarUseBefore09SizeComputation)
+        {
 
-        // Scale is multiplier of radius with one of "0.5"
+            // Bullet's capsule total height is the "passed height + radius * 2";
+            // 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.
+            // 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.
 
-        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)
+            // Scale is multiplier of radius with one of "0.5"
+
+            float heightAdjust = BSParam.AvatarHeightMidFudge;
+            if (BSParam.AvatarHeightLowFudge != 0f || BSParam.AvatarHeightHighFudge != 0f)
             {
-                // Small avatar. Add the adjustment based on the distance from midheight
-                heightAdjust += ((-1f * midHeightOffset) / (AVATAR_MID - AVATAR_LOW)) * BSParam.AvatarHeightLowFudge;
+                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;
+                }
+            }
+            if (BSParam.AvatarShape == BSShapeCollection.AvatarShapeCapsule)
+            {
+                newScale.X = size.X / 2f;
+                newScale.Y = size.Y / 2f;
+                // 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) + heightAdjust) / 2f;
             }
             else
             {
-                // Large avatar. Add the adjustment based on the distance from midheight
-                heightAdjust += ((midHeightOffset) / (AVATAR_HI - AVATAR_MID)) * BSParam.AvatarHeightHighFudge;
+                newScale.Z = size.Z + heightAdjust;
             }
-        }
-        if (BSParam.AvatarShape == BSShapeCollection.AvatarShapeCapsule)
-        {
-            newScale.X = size.X / 2f;
-            newScale.Y = size.Y / 2f;
-            // 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) + 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.ComputeAvatarScale,size={1},lowF={2},midF={3},hiF={4},adj={5},newScale={6}",
+                LocalID, size, BSParam.AvatarHeightLowFudge, BSParam.AvatarHeightMidFudge, BSParam.AvatarHeightHighFudge, heightAdjust, newScale);
         }
         else
         {
-            newScale.Z = size.Z + heightAdjust;
+            newScale.Z = size.Z + _footOffset;
+            DetailLog("{0},BSCharacter.ComputeAvatarScale,using newScale={1}, footOffset={2}", LocalID, newScale, _footOffset);
         }
-        // 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;
     }
@@ -744,17 +786,24 @@ public sealed class BSCharacter : BSPhysObject
     // set _avatarVolume and _mass based on capsule size, _density and Scale
     private void ComputeAvatarVolumeAndMass()
     {
-        _avatarVolume = (float)(
-                        Math.PI
-                        * Size.X / 2f
-                        * Size.Y / 2f    // the area of capsule cylinder
-                        * Size.Z         // times height of capsule cylinder
-                      + 1.33333333f
-                        * Math.PI
-                        * Size.X / 2f
-                        * Math.Min(Size.X, Size.Y) / 2
-                        * Size.Y / 2f    // plus the volume of the capsule end caps
-                        );
+        if (BSParam.AvatarShape == BSShapeCollection.AvatarShapeCapsule)
+        {
+            _avatarVolume = (float)(
+                            Math.PI
+                            * Size.X / 2f
+                            * Size.Y / 2f    // the area of capsule cylinder
+                            * Size.Z         // times height of capsule cylinder
+                          + 1.33333333f
+                            * Math.PI
+                            * Size.X / 2f
+                            * Math.Min(Size.X, Size.Y) / 2
+                            * Size.Y / 2f    // plus the volume of the capsule end caps
+                            );
+        }
+        else
+        {
+            _avatarVolume = Size.X * Size.Y * Size.Z;
+        }
         _mass = Density * BSParam.DensityScaleFactor * _avatarVolume;
     }
 
@@ -773,7 +822,7 @@ public sealed class BSCharacter : BSPhysObject
         //    0.001m/s. Bullet introduces a lot of jitter in the velocity which causes many
         //    extra updates.
         //
-        // XXX: Contrary to the above comment, setting an update threshold here above 0.4 actually introduces jitter to 
+        // XXX: Contrary to the above comment, setting an update threshold here above 0.4 actually introduces jitter to
         // avatar movement rather than removes it.  The larger the threshold, the bigger the jitter.
         // This is most noticeable in level flight and can be seen with
         // the "show updates" option in a viewer.  With an update threshold, the RawVelocity cycles between a lower
@@ -787,7 +836,7 @@ public sealed class BSCharacter : BSPhysObject
             RawVelocity = entprop.Velocity;
 
         _acceleration = entprop.Acceleration;
-        _rotationalVelocity = entprop.RotationalVelocity;
+        RawRotationalVelocity = entprop.RotationalVelocity;
 
         // Do some sanity checking for the avatar. Make sure it's above ground and inbounds.
         if (PositionSanityCheck(true))
@@ -807,7 +856,7 @@ public sealed class BSCharacter : BSPhysObject
         // PhysScene.PostUpdate(this);
 
         DetailLog("{0},BSCharacter.UpdateProperties,call,pos={1},orient={2},vel={3},accel={4},rotVel={5}",
-                LocalID, RawPosition, RawOrientation, RawVelocity, _acceleration, _rotationalVelocity);
+                LocalID, RawPosition, RawOrientation, RawVelocity, _acceleration, RawRotationalVelocity);
     }
 }
 }
diff --git a/OpenSim/Region/PhysicsModules/BulletS/BSConstraint.cs b/OpenSim/Region/PhysicsModules/BulletS/BSConstraint.cs
index e42e868..e42e868 100644..100755
--- a/OpenSim/Region/PhysicsModules/BulletS/BSConstraint.cs
+++ b/OpenSim/Region/PhysicsModules/BulletS/BSConstraint.cs
diff --git a/OpenSim/Region/PhysicsModules/BulletS/BSConstraint6Dof.cs b/OpenSim/Region/PhysicsModules/BulletS/BSConstraint6Dof.cs
index 4bcde2b..4bcde2b 100644..100755
--- a/OpenSim/Region/PhysicsModules/BulletS/BSConstraint6Dof.cs
+++ b/OpenSim/Region/PhysicsModules/BulletS/BSConstraint6Dof.cs
diff --git a/OpenSim/Region/PhysicsModules/BulletS/BSConstraintCollection.cs b/OpenSim/Region/PhysicsModules/BulletS/BSConstraintCollection.cs
index 5746ac1..5746ac1 100644..100755
--- a/OpenSim/Region/PhysicsModules/BulletS/BSConstraintCollection.cs
+++ b/OpenSim/Region/PhysicsModules/BulletS/BSConstraintCollection.cs
diff --git a/OpenSim/Region/PhysicsModules/BulletS/BSConstraintConeTwist.cs b/OpenSim/Region/PhysicsModules/BulletS/BSConstraintConeTwist.cs
index e7566a8..e7566a8 100644..100755
--- a/OpenSim/Region/PhysicsModules/BulletS/BSConstraintConeTwist.cs
+++ b/OpenSim/Region/PhysicsModules/BulletS/BSConstraintConeTwist.cs
diff --git a/OpenSim/Region/PhysicsModules/BulletS/BSConstraintHinge.cs b/OpenSim/Region/PhysicsModules/BulletS/BSConstraintHinge.cs
index d20538d..d20538d 100644..100755
--- a/OpenSim/Region/PhysicsModules/BulletS/BSConstraintHinge.cs
+++ b/OpenSim/Region/PhysicsModules/BulletS/BSConstraintHinge.cs
diff --git a/OpenSim/Region/PhysicsModules/BulletS/BSConstraintSlider.cs b/OpenSim/Region/PhysicsModules/BulletS/BSConstraintSlider.cs
index 83d42af..83d42af 100644..100755
--- a/OpenSim/Region/PhysicsModules/BulletS/BSConstraintSlider.cs
+++ b/OpenSim/Region/PhysicsModules/BulletS/BSConstraintSlider.cs
diff --git a/OpenSim/Region/PhysicsModules/BulletS/BSConstraintSpring.cs b/OpenSim/Region/PhysicsModules/BulletS/BSConstraintSpring.cs
index 563a1b1..563a1b1 100644..100755
--- a/OpenSim/Region/PhysicsModules/BulletS/BSConstraintSpring.cs
+++ b/OpenSim/Region/PhysicsModules/BulletS/BSConstraintSpring.cs
diff --git a/OpenSim/Region/PhysicsModules/BulletS/BSDynamics.cs b/OpenSim/Region/PhysicsModules/BulletS/BSDynamics.cs
index 0fc5577..c4ccdbe 100644
--- a/OpenSim/Region/PhysicsModules/BulletS/BSDynamics.cs
+++ b/OpenSim/Region/PhysicsModules/BulletS/BSDynamics.cs
@@ -125,8 +125,8 @@ namespace OpenSim.Region.PhysicsModule.BulletS
 
         // Just some recomputed constants:
 #pragma warning disable 414
-        static readonly float TwoPI = ((float)Math.PI) * 2f; 
-        static readonly float FourPI = ((float)Math.PI) * 4f; 
+        static readonly float TwoPI = ((float)Math.PI) * 2f;
+        static readonly float FourPI = ((float)Math.PI) * 4f;
         static readonly float PIOverFour = ((float)Math.PI) / 4f;
         static readonly float PIOverTwo = ((float)Math.PI) / 2f;
 #pragma warning restore 414
@@ -768,7 +768,7 @@ namespace OpenSim.Region.PhysicsModule.BulletS
                 }
 
                 if ((m_knownChanged & m_knownChangedForce) != 0)
-                    ControllingPrim.AddForce((Vector3)m_knownForce, false /*pushForce*/, true /*inTaintTime*/);
+                    ControllingPrim.AddForce(false /* inTaintTime */, (Vector3)m_knownForce);
 
                 if ((m_knownChanged & m_knownChangedForceImpulse) != 0)
                     ControllingPrim.AddForceImpulse((Vector3)m_knownForceImpulse, false /*pushforce*/, true /*inTaintTime*/);
@@ -784,7 +784,7 @@ namespace OpenSim.Region.PhysicsModule.BulletS
 
                 if ((m_knownChanged & m_knownChangedRotationalForce) != 0)
                 {
-                    ControllingPrim.AddAngularForce((Vector3)m_knownRotationalForce, false /*pushForce*/, true /*inTaintTime*/);
+                    ControllingPrim.AddAngularForce(true /* inTaintTime */, (Vector3)m_knownRotationalForce);
                 }
 
                 // If we set one of the values (ie, the physics engine didn't do it) we must force
@@ -1595,7 +1595,7 @@ namespace OpenSim.Region.PhysicsModule.BulletS
         //     in that direction.
         // TODO: implement reference frame.
         public void ComputeAngularDeflection()
-        {   
+        {
 
             if (BSParam.VehicleEnableAngularDeflection && m_angularDeflectionEfficiency != 0 && VehicleForwardSpeed > 0.2)
             {
diff --git a/OpenSim/Region/PhysicsModules/BulletS/BSLinkset.cs b/OpenSim/Region/PhysicsModules/BulletS/BSLinkset.cs
index 8312239..13c1361 100644..100755
--- a/OpenSim/Region/PhysicsModules/BulletS/BSLinkset.cs
+++ b/OpenSim/Region/PhysicsModules/BulletS/BSLinkset.cs
@@ -257,7 +257,7 @@ public abstract class BSLinkset
     // 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,
+    public virtual bool HandleCollide(BSPhysObject collider, BSPhysObject collidee,
                                 OMV.Vector3 contactPoint, OMV.Vector3 contactNormal, float pentrationDepth)
     {
         bool ret = false;
@@ -319,7 +319,7 @@ public abstract class BSLinkset
     public virtual bool AllPartsComplete
     {
         get {
-            bool ret = true; 
+            bool ret = true;
             this.ForEachMember((member) =>
             {
                 if ((!member.IsInitialized) || member.IsIncomplete || member.PrimAssetState == BSPhysObject.PrimAssetCondition.Waiting)
diff --git a/OpenSim/Region/PhysicsModules/BulletS/BSLinksetCompound.cs b/OpenSim/Region/PhysicsModules/BulletS/BSLinksetCompound.cs
index 953ddee..dc390b2 100644..100755
--- a/OpenSim/Region/PhysicsModules/BulletS/BSLinksetCompound.cs
+++ b/OpenSim/Region/PhysicsModules/BulletS/BSLinksetCompound.cs
@@ -450,6 +450,7 @@ public sealed class BSLinksetCompound : BSLinkset
             m_physicsScene.PE.AddObjectToWorld(m_physicsScene.World, LinksetRoot.PhysBody);
             DetailLog("{0},BSLinksetCompound.RecomputeLinksetCompound,addBody,body={1},shape={2}",
                                         LinksetRoot.LocalID, LinksetRoot.PhysBody, linksetShape);
+            m_physicsScene.PE.ResetBroadphasePool(m_physicsScene.World);    // DEBUG DEBUG
 
             // With all of the linkset packed into the root prim, it has the mass of everyone.
             LinksetMass = ComputeLinksetMass();
diff --git a/OpenSim/Region/PhysicsModules/BulletS/BSLinksetConstraints.cs b/OpenSim/Region/PhysicsModules/BulletS/BSLinksetConstraints.cs
index c4b4c86..c4b4c86 100644..100755
--- a/OpenSim/Region/PhysicsModules/BulletS/BSLinksetConstraints.cs
+++ b/OpenSim/Region/PhysicsModules/BulletS/BSLinksetConstraints.cs
diff --git a/OpenSim/Region/PhysicsModules/BulletS/BSMaterials.cs b/OpenSim/Region/PhysicsModules/BulletS/BSMaterials.cs
index 0e44d03..0e44d03 100644..100755
--- a/OpenSim/Region/PhysicsModules/BulletS/BSMaterials.cs
+++ b/OpenSim/Region/PhysicsModules/BulletS/BSMaterials.cs
diff --git a/OpenSim/Region/PhysicsModules/BulletS/BSMotors.cs b/OpenSim/Region/PhysicsModules/BulletS/BSMotors.cs
index 2faf2d4..2faf2d4 100644..100755
--- a/OpenSim/Region/PhysicsModules/BulletS/BSMotors.cs
+++ b/OpenSim/Region/PhysicsModules/BulletS/BSMotors.cs
diff --git a/OpenSim/Region/PhysicsModules/BulletS/BSParam.cs b/OpenSim/Region/PhysicsModules/BulletS/BSParam.cs
index c296008..495f752 100644..100755
--- a/OpenSim/Region/PhysicsModules/BulletS/BSParam.cs
+++ b/OpenSim/Region/PhysicsModules/BulletS/BSParam.cs
@@ -90,8 +90,8 @@ public static class BSParam
     public static float DeactivationTime { get; private set; }
     public static float LinearSleepingThreshold { get; private set; }
     public static float AngularSleepingThreshold { get; private set; }
-        public static float CcdMotionThreshold { get; private set; }
-        public static float CcdSweptSphereRadius { get; private set; }
+    public static float CcdMotionThreshold { get; private set; }
+    public static float CcdSweptSphereRadius { get; private set; }
     public static float ContactProcessingThreshold { get; private set; }
 
     public static bool ShouldMeshSculptedPrim { get; private set; }   // cause scuplted prims to get meshed
@@ -119,14 +119,14 @@ public static class BSParam
     public static float Gravity { get; private set; }
 
     // Physics Engine operation
-        public static float MaxPersistantManifoldPoolSize { get; private set; }
-        public static float MaxCollisionAlgorithmPoolSize { get; private set; }
-        public static bool ShouldDisableContactPoolDynamicAllocation { get; private set; }
-        public static bool ShouldForceUpdateAllAabbs { get; private set; }
-        public static bool ShouldRandomizeSolverOrder { get; private set; }
-        public static bool ShouldSplitSimulationIslands { get; private set; }
-        public static bool ShouldEnableFrictionCaching { get; private set; }
-        public static float NumberOfSolverIterations { get; private set; }
+    public static float MaxPersistantManifoldPoolSize { get; private set; }
+    public static float MaxCollisionAlgorithmPoolSize { get; private set; }
+    public static bool ShouldDisableContactPoolDynamicAllocation { get; private set; }
+    public static bool ShouldForceUpdateAllAabbs { get; private set; }
+    public static bool ShouldRandomizeSolverOrder { get; private set; }
+    public static bool ShouldSplitSimulationIslands { get; private set; }
+    public static bool ShouldEnableFrictionCaching { get; private set; }
+    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; }
@@ -135,6 +135,7 @@ public static class BSParam
     public static bool AvatarToAvatarCollisionsByDefault { get; private set; }
     public static float AvatarFriction { get; private set; }
     public static float AvatarStandingFriction { get; private set; }
+    public static float AvatarWalkVelocityFactor { get; private set; }
     public static float AvatarAlwaysRunFactor { get; private set; }
     public static float AvatarDensity { get; private set; }
     public static float AvatarRestitution { get; private set; }
@@ -142,23 +143,26 @@ 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 bool AvatarUseBefore09SizeComputation { 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 AvatarFlyingGroundMargin { get; private set; }
     public static float AvatarFlyingGroundUpForce { get; private set; }
     public static float AvatarTerminalVelocity { get; private set; }
-        public static float AvatarContactProcessingThreshold { get; private set; }
+    public static float AvatarContactProcessingThreshold { get; private set; }
+    public static float AvatarAddForcePushFactor { 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 AvatarStepAngle { get; private set; }
-        public static float AvatarStepGroundFudge { 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; }
+    public static float AvatarStopZeroThresholdSquared { 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 AvatarStepAngle { get; private set; }
+    public static float AvatarStepGroundFudge { 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; }
@@ -190,31 +194,31 @@ 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
-        public static float WhichHACD { get; private set; }                                 // zero if Bullet HACD, non-zero says VHACD
+    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
+    public static float WhichHACD { get; private set; }                             // zero if Bullet HACD, non-zero says VHACD
     // Parameters for VHACD 2.0: http://code.google.com/p/v-hacd
     // To enable, set both ShouldUseBulletHACD=true and WhichHACD=1
-        // http://kmamou.blogspot.ca/2014/12/v-hacd-20-parameters-description.html
-        public static float VHACDresolution { get; private set; }                       // 100,000 max number of voxels generated during voxelization stage
-        public static float VHACDdepth { get; private set; }                            // 20 max number of clipping stages
-        public static float VHACDconcavity { get; private set; }                        // 0.0025 maximum concavity
-        public static float VHACDplaneDownsampling { get; private set; }        // 4 granularity of search for best clipping plane
-        public static float VHACDconvexHullDownsampling { get; private set; }   // 4 precision of hull gen process
-        public static float VHACDalpha { get; private set; }                            // 0.05 bias toward clipping along symmetry planes
-        public static float VHACDbeta { get; private set; }                                 // 0.05 bias toward clipping along revolution axis
-        public static float VHACDgamma { get; private set; }                            // 0.00125 max concavity when merging
-        public static float VHACDpca { get; private set; }                                      // 0 on/off normalizing mesh before decomp
-        public static float VHACDmode { get; private set; }                                 // 0 0:voxel based, 1: tetrahedron based
-        public static float VHACDmaxNumVerticesPerCH { get; private set; }      // 64 max triangles per convex hull
-        public static float VHACDminVolumePerCH { get; private set; }           // 0.0001 sampling of generated convex hulls
+    // http://kmamou.blogspot.ca/2014/12/v-hacd-20-parameters-description.html
+    public static float VHACDresolution { get; private set; }                   // 100,000 max number of voxels generated during voxelization stage
+    public static float VHACDdepth { get; private set; }                                // 20 max number of clipping stages
+    public static float VHACDconcavity { get; private set; }                    // 0.0025 maximum concavity
+    public static float VHACDplaneDownsampling { get; private set; }    // 4 granularity of search for best clipping plane
+    public static float VHACDconvexHullDownsampling { get; private set; }       // 4 precision of hull gen process
+    public static float VHACDalpha { get; private set; }                                // 0.05 bias toward clipping along symmetry planes
+    public static float VHACDbeta { get; private set; }                             // 0.05 bias toward clipping along revolution axis
+    public static float VHACDgamma { get; private set; }                                // 0.00125 max concavity when merging
+    public static float VHACDpca { get; private set; }                                  // 0 on/off normalizing mesh before decomp
+    public static float VHACDmode { get; private set; }                             // 0 0:voxel based, 1: tetrahedron based
+    public static float VHACDmaxNumVerticesPerCH { get; private set; }  // 64 max triangles per convex hull
+    public static float VHACDminVolumePerCH { get; private set; }               // 0.0001 sampling of generated convex hulls
 
     // Linkset implementation parameters
     public static float LinksetImplementation { get; private set; }
@@ -227,9 +231,13 @@ public static class BSParam
     public static float LinkConstraintCFM { get; private set; }
     public static float LinkConstraintSolverIterations { get; private set; }
 
+    public static bool UseBulletRaycast { get; private set; }
+
     public static float PID_D { get; private set; }    // derivative
     public static float PID_P { get; private set; }    // proportional
 
+    public static float DebugNumber { get; private set; }   // A console setable number used for debugging
+
     // Various constants that come from that other virtual world that shall not be named.
     public const float MinGravityZ = -1f;
     public const float MaxGravityZ = 28f;
@@ -574,7 +582,7 @@ public static class BSParam
             (s,v) => { ContactProcessingThreshold = v;},
             (s,o) => { s.PE.SetContactProcessingThreshold(o.PhysBody, ContactProcessingThreshold); } ),
 
-            new ParameterDefn<float>("TerrainImplementation", "Type of shape to use for terrain (0=heightmap, 1=mesh)",
+        new ParameterDefn<float>("TerrainImplementation", "Type of shape to use for terrain (0=heightmap, 1=mesh)",
             (float)BSTerrainPhys.TerrainImplementation.Heightmap ),
         new ParameterDefn<int>("TerrainMeshMagnification", "Number of times the 256x256 heightmap is multiplied to create the terrain mesh" ,
             2 ),
@@ -597,11 +605,13 @@ public static class BSParam
             0.2f ),
         new ParameterDefn<float>("AvatarStandingFriction", "Avatar friction when standing. Changed on avatar recreation.",
             0.95f ),
+        new ParameterDefn<float>("AvatarWalkVelocityFactor", "Speed multiplier if avatar is walking",
+            1.0f ),
         new ParameterDefn<float>("AvatarAlwaysRunFactor", "Speed multiplier if avatar is set to always run",
             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
+            350f) ,    // 3.5 * 100
         new ParameterDefn<float>("AvatarRestitution", "Bouncyness. Changed on avatar recreation.",
             0f ),
         new ParameterDefn<int>("AvatarShape", "Code for avatar physical shape: 0:capsule, 1:cube, 2:ovoid, 2:mesh",
@@ -612,6 +622,8 @@ public static class BSParam
             0.45f ),
         new ParameterDefn<float>("AvatarCapsuleHeight", "Default height of space around avatar",
             1.5f ),
+        new ParameterDefn<bool>("AvatarUseBefore09SizeComputation", "Use the old fudge method of computing avatar capsule size",
+            true ),
         new ParameterDefn<float>("AvatarHeightLowFudge", "A fudge factor to make small avatars stand on the ground",
             0f ),
         new ParameterDefn<float>("AvatarHeightMidFudge", "A fudge distance to adjust average sized avatars to be standing on ground",
@@ -624,27 +636,31 @@ public static class BSParam
             2.0f ),
         new ParameterDefn<float>("AvatarTerminalVelocity", "Terminal Velocity of falling avatar",
             -54.0f ),
-            new ParameterDefn<float>("AvatarContactProcessingThreshold", "Distance from capsule to check for collisions",
-            0.1f ),
-            new ParameterDefn<float>("AvatarStopZeroThreshold", "Movement velocity below which avatar is assumed to be stopped",
+        new ParameterDefn<float>("AvatarContactProcessingThreshold", "Distance from capsule to check for collisions",
             0.1f ),
-            new ParameterDefn<float>("AvatarBelowGroundUpCorrectionMeters", "Meters to move avatar up if it seems to be below ground",
+        new ParameterDefn<float>("AvatarAddForcePushFactor", "BSCharacter.AddForce is multiplied by this and mass to be like other physics engines",
+            0.315f ),
+        new ParameterDefn<float>("AvatarStopZeroThreshold", "Movement velocity below which avatar is assumed to be stopped",
+            0.45f,
+            (s) => { return (float)AvatarStopZeroThreshold; },
+            (s,v) => { AvatarStopZeroThreshold = v; AvatarStopZeroThresholdSquared = v * v; } ),
+        new ParameterDefn<float>("AvatarBelowGroundUpCorrectionMeters", "Meters to move avatar up if it seems to be below ground",
             1.0f ),
-            new ParameterDefn<int>("AvatarJumpFrames", "Number of frames to allow jump forces. Changes jump height.",
+        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",
+        new ParameterDefn<float>("AvatarStepHeight", "Height of a step obstacle to consider step correction",
             0.999f ) ,
-            new ParameterDefn<float>("AvatarStepAngle", "The angle (in radians) for a vertical surface to be considered a step",
+        new ParameterDefn<float>("AvatarStepAngle", "The angle (in radians) for a vertical surface to be considered a step",
             0.3f ) ,
-            new ParameterDefn<float>("AvatarStepGroundFudge", "Fudge factor subtracted from avatar base when comparing collision height",
+        new ParameterDefn<float>("AvatarStepGroundFudge", "Fudge factor subtracted from avatar base when comparing collision height",
             0.1f ) ,
-            new ParameterDefn<float>("AvatarStepApproachFactor", "Factor to control angle of approach to step (0=straight on)",
+        new ParameterDefn<float>("AvatarStepApproachFactor", "Factor to control angle of approach to step (0=straight on)",
             2f ),
-            new ParameterDefn<float>("AvatarStepForceFactor", "Controls the amount of force up applied to step up onto a step",
+        new ParameterDefn<float>("AvatarStepForceFactor", "Controls the amount of force up applied to step up onto a step",
             0f ),
-            new ParameterDefn<float>("AvatarStepUpCorrectionFactor", "Multiplied by height of step collision to create up movement at step",
+        new ParameterDefn<float>("AvatarStepUpCorrectionFactor", "Multiplied by height of step collision to create up movement at step",
             0.8f ),
-            new ParameterDefn<int>("AvatarStepSmoothingSteps", "Number of frames after a step collision that we continue walking up stairs",
+        new ParameterDefn<int>("AvatarStepSmoothingSteps", "Number of frames after a step collision that we continue walking up stairs",
             1 ),
 
         new ParameterDefn<float>("VehicleMaxLinearVelocity", "Maximum velocity magnitude that can be assigned to a vehicle",
@@ -688,130 +704,136 @@ public static class BSParam
         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)",
+        new ParameterDefn<float>("MaxPersistantManifoldPoolSize", "Number of manifolds pooled (0 means default of 4096)",
             0f,
             (s) => { return MaxPersistantManifoldPoolSize; },
             (s,v) => { MaxPersistantManifoldPoolSize = v; s.UnmanagedParams[0].maxPersistantManifoldPoolSize = v; } ),
-            new ParameterDefn<float>("MaxCollisionAlgorithmPoolSize", "Number of collisions pooled (0 means default of 4096)",
+        new ParameterDefn<float>("MaxCollisionAlgorithmPoolSize", "Number of collisions pooled (0 means default of 4096)",
             0f,
             (s) => { return MaxCollisionAlgorithmPoolSize; },
             (s,v) => { MaxCollisionAlgorithmPoolSize = v; s.UnmanagedParams[0].maxCollisionAlgorithmPoolSize = v; } ),
-            new ParameterDefn<bool>("ShouldDisableContactPoolDynamicAllocation", "Enable to allow large changes in object count",
+        new ParameterDefn<bool>("ShouldDisableContactPoolDynamicAllocation", "Enable to allow large changes in object count",
             false,
             (s) => { return ShouldDisableContactPoolDynamicAllocation; },
             (s,v) => { ShouldDisableContactPoolDynamicAllocation = v;
                         s.UnmanagedParams[0].shouldDisableContactPoolDynamicAllocation = NumericBool(v); } ),
-            new ParameterDefn<bool>("ShouldForceUpdateAllAabbs", "Enable to recomputer AABBs every simulator step",
+        new ParameterDefn<bool>("ShouldForceUpdateAllAabbs", "Enable to recomputer AABBs every simulator step",
             false,
             (s) => { return ShouldForceUpdateAllAabbs; },
             (s,v) => { ShouldForceUpdateAllAabbs = v; s.UnmanagedParams[0].shouldForceUpdateAllAabbs = NumericBool(v); } ),
-            new ParameterDefn<bool>("ShouldRandomizeSolverOrder", "Enable for slightly better stacking interaction",
+        new ParameterDefn<bool>("ShouldRandomizeSolverOrder", "Enable for slightly better stacking interaction",
             true,
             (s) => { return ShouldRandomizeSolverOrder; },
             (s,v) => { ShouldRandomizeSolverOrder = v; s.UnmanagedParams[0].shouldRandomizeSolverOrder = NumericBool(v); } ),
-            new ParameterDefn<bool>("ShouldSplitSimulationIslands", "Enable splitting active object scanning islands",
+        new ParameterDefn<bool>("ShouldSplitSimulationIslands", "Enable splitting active object scanning islands",
             true,
             (s) => { return ShouldSplitSimulationIslands; },
             (s,v) => { ShouldSplitSimulationIslands = v; s.UnmanagedParams[0].shouldSplitSimulationIslands = NumericBool(v); } ),
-            new ParameterDefn<bool>("ShouldEnableFrictionCaching", "Enable friction computation caching",
+        new ParameterDefn<bool>("ShouldEnableFrictionCaching", "Enable friction computation caching",
             true,
             (s) => { return ShouldEnableFrictionCaching; },
             (s,v) => { ShouldEnableFrictionCaching = v; s.UnmanagedParams[0].shouldEnableFrictionCaching = NumericBool(v); } ),
-            new ParameterDefn<float>("NumberOfSolverIterations", "Number of internal iterations (0 means default)",
+        new ParameterDefn<float>("NumberOfSolverIterations", "Number of internal iterations (0 means default)",
             0f,     // zero says use Bullet default
             (s) => { return NumberOfSolverIterations; },
             (s,v) => { NumberOfSolverIterations = v; s.UnmanagedParams[0].numberOfSolverIterations = v; } ),
-            new ParameterDefn<bool>("UseSingleSidedMeshes", "Whether to compute collisions based on single sided meshes.",
+        new ParameterDefn<bool>("UseSingleSidedMeshes", "Whether to compute collisions based on single sided meshes.",
             true,
             (s) => { return UseSingleSidedMeshes; },
             (s,v) => { UseSingleSidedMeshes = v; s.UnmanagedParams[0].useSingleSidedMeshes = NumericBool(v); } ),
-            new ParameterDefn<float>("GlobalContactBreakingThreshold", "Amount of shape radius before breaking a collision contact (0 says Bullet default (0.2))",
+        new ParameterDefn<float>("GlobalContactBreakingThreshold", "Amount of shape radius before breaking a collision contact (0 says Bullet default (0.2))",
             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",
+        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",
+        new ParameterDefn<int>("CSHullMaxDepthSplit", "CS impl: max depth to split for hull. 1-10 but > 7 is iffy",
             7 ),
-            new ParameterDefn<int>("CSHullMaxDepthSplitForSimpleShapes", "CS impl: max depth setting for simple prim shapes",
+        new ParameterDefn<int>("CSHullMaxDepthSplitForSimpleShapes", "CS impl: max depth setting for simple prim shapes",
             2 ),
-            new ParameterDefn<float>("CSHullConcavityThresholdPercent", "CS impl: concavity threshold percent (0-20)",
+        new ParameterDefn<float>("CSHullConcavityThresholdPercent", "CS impl: concavity threshold percent (0-20)",
             5f ),
-            new ParameterDefn<float>("CSHullVolumeConservationThresholdPercent", "percent volume conservation to collapse hulls (0-30)",
+        new ParameterDefn<float>("CSHullVolumeConservationThresholdPercent", "percent volume conservation to collapse hulls (0-30)",
             5f ),
-            new ParameterDefn<int>("CSHullMaxVertices", "CS impl: maximum number of vertices in output hulls. Keep < 50.",
+        new ParameterDefn<int>("CSHullMaxVertices", "CS impl: maximum number of vertices in output hulls. Keep < 50.",
             32 ),
-            new ParameterDefn<float>("CSHullMaxSkinWidth", "CS impl: skin width to apply to output hulls.",
+        new ParameterDefn<float>("CSHullMaxSkinWidth", "CS impl: skin width to apply to output hulls.",
             0f ),
 
-            new ParameterDefn<float>("BHullMaxVerticesPerHull", "Bullet impl: max number of vertices per created hull",
+        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",
+        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",
+        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",
+        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",
+        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",
+        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",
+        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",
+        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",
+        new ParameterDefn<bool>("BHullShouldAdjustCollisionMargin", "Bullet impl: whether to shrink resulting hulls to account for collision margin",
             false ),
 
-            new ParameterDefn<float>("WhichHACD", "zero if Bullet HACD, non-zero says VHACD",
+        new ParameterDefn<float>("WhichHACD", "zero if Bullet HACD, non-zero says VHACD",
             0f ),
-            new ParameterDefn<float>("VHACDresolution", "max number of voxels generated during voxelization stage",
+        new ParameterDefn<float>("VHACDresolution", "max number of voxels generated during voxelization stage",
             100000f ),
-            new ParameterDefn<float>("VHACDdepth", "max number of clipping stages",
+        new ParameterDefn<float>("VHACDdepth", "max number of clipping stages",
             20f ),
-            new ParameterDefn<float>("VHACDconcavity", "maximum concavity",
+        new ParameterDefn<float>("VHACDconcavity", "maximum concavity",
             0.0025f ),
-            new ParameterDefn<float>("VHACDplaneDownsampling", "granularity of search for best clipping plane",
+        new ParameterDefn<float>("VHACDplaneDownsampling", "granularity of search for best clipping plane",
             4f ),
-            new ParameterDefn<float>("VHACDconvexHullDownsampling", "precision of hull gen process",
+        new ParameterDefn<float>("VHACDconvexHullDownsampling", "precision of hull gen process",
             4f ),
-            new ParameterDefn<float>("VHACDalpha", "bias toward clipping along symmetry planes",
+        new ParameterDefn<float>("VHACDalpha", "bias toward clipping along symmetry planes",
             0.05f ),
-            new ParameterDefn<float>("VHACDbeta", "bias toward clipping along revolution axis",
+        new ParameterDefn<float>("VHACDbeta", "bias toward clipping along revolution axis",
             0.05f ),
-            new ParameterDefn<float>("VHACDgamma", "max concavity when merging",
+        new ParameterDefn<float>("VHACDgamma", "max concavity when merging",
             0.00125f ),
-            new ParameterDefn<float>("VHACDpca", "on/off normalizing mesh before decomp",
+        new ParameterDefn<float>("VHACDpca", "on/off normalizing mesh before decomp",
             0f ),
-            new ParameterDefn<float>("VHACDmode", "0:voxel based, 1: tetrahedron based",
+        new ParameterDefn<float>("VHACDmode", "0:voxel based, 1: tetrahedron based",
             0f ),
-            new ParameterDefn<float>("VHACDmaxNumVerticesPerCH", "max triangles per convex hull",
+        new ParameterDefn<float>("VHACDmaxNumVerticesPerCH", "max triangles per convex hull",
             64f ),
-            new ParameterDefn<float>("VHACDminVolumePerCH",     "sampling of generated convex hulls",
+        new ParameterDefn<float>("VHACDminVolumePerCH", "sampling of generated convex hulls",
             0.0001f ),
 
-            new ParameterDefn<float>("LinksetImplementation", "Type of linkset implementation (0=Constraint, 1=Compound, 2=Manual)",
+        new ParameterDefn<float>("LinksetImplementation", "Type of linkset implementation (0=Constraint, 1=Compound, 2=Manual)",
             (float)BSLinkset.LinksetImplementation.Compound ),
-            new ParameterDefn<bool>("LinksetOffsetCenterOfMass", "If 'true', compute linkset center-of-mass and offset linkset position to account for same",
+        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.",
+        new ParameterDefn<bool>("LinkConstraintUseFrameOffset", "For linksets built with constraints, enable frame offsetFor linksets built with constraints, enable frame offset.",
             false ),
-            new ParameterDefn<bool>("LinkConstraintEnableTransMotor", "Whether to enable translational motor on linkset constraints",
+        new ParameterDefn<bool>("LinkConstraintEnableTransMotor", "Whether to enable translational motor on linkset constraints",
             true ),
-            new ParameterDefn<float>("LinkConstraintTransMotorMaxVel", "Maximum velocity to be applied by translational motor in linkset constraints",
+        new ParameterDefn<float>("LinkConstraintTransMotorMaxVel", "Maximum velocity to be applied by translational motor in linkset constraints",
             5.0f ),
-            new ParameterDefn<float>("LinkConstraintTransMotorMaxForce", "Maximum force to be applied by translational motor in linkset constraints",
+        new ParameterDefn<float>("LinkConstraintTransMotorMaxForce", "Maximum force to be applied by translational motor in linkset constraints",
             0.1f ),
-            new ParameterDefn<float>("LinkConstraintCFM", "Amount constraint can be violated. 0=no violation, 1=infinite. Default=0.1",
+        new ParameterDefn<float>("LinkConstraintCFM", "Amount constraint can be violated. 0=no violation, 1=infinite. Default=0.1",
             0.1f ),
-            new ParameterDefn<float>("LinkConstraintERP", "Amount constraint is corrected each tick. 0=none, 1=all. Default = 0.2",
+        new ParameterDefn<float>("LinkConstraintERP", "Amount constraint is corrected each tick. 0=none, 1=all. Default = 0.2",
             0.1f ),
-            new ParameterDefn<float>("LinkConstraintSolverIterations", "Number of solver iterations when computing constraint. (0 = Bullet default)",
+        new ParameterDefn<float>("LinkConstraintSolverIterations", "Number of solver iterations when computing constraint. (0 = Bullet default)",
             40 ),
 
+        new ParameterDefn<bool>("UseBulletRaycast", "If 'true', use the raycast function of the Bullet physics engine",
+            true ),
+
+        new ParameterDefn<float>("DebugNumber", "A console setable number sometimes used for debugging",
+            1.0f ),
+
         new ParameterDefn<int>("PhysicsMetricFrames", "Frames between outputting detailed phys metrics. (0 is off)",
             0,
             (s) => { return s.PhysicsMetricDumpFrames; },
@@ -819,7 +841,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, false /* inTaintTime */); } ),
+            (s,v) => { BSParam.ResetBroadphasePoolTainted(s, v); } ),
         new ParameterDefn<float>("ResetConstraintSolver", "Setting this is any value resets the constraint solver",
             0f,
             (s) => { return 0f; },
@@ -905,10 +927,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, bool inTaintTime)
+    private static void ResetBroadphasePoolTainted(BSScene pPhysScene, float v)
     {
         BSScene physScene = pPhysScene;
-        physScene.TaintedObject(inTaintTime, "BSParam.ResetBroadphasePoolTainted", delegate()
+        physScene.TaintedObject(BSScene.DetailLogZero, "BSParam.ResetBroadphasePoolTainted", delegate()
         {
             physScene.PE.ResetBroadphasePool(physScene.World);
         });
diff --git a/OpenSim/Region/PhysicsModules/BulletS/BSPhysObject.cs b/OpenSim/Region/PhysicsModules/BulletS/BSPhysObject.cs
index da3fc18..6aa24d5 100644..100755
--- a/OpenSim/Region/PhysicsModules/BulletS/BSPhysObject.cs
+++ b/OpenSim/Region/PhysicsModules/BulletS/BSPhysObject.cs
@@ -230,34 +230,97 @@ 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);
 
+    // The position value as known by BulletSim. Does not effect the physics engine.
     public virtual OMV.Vector3 RawPosition { get; set; }
+    // Set position in BulletSim and the physics engined to a value immediately. Must be called at taint time.
     public abstract OMV.Vector3 ForcePosition { get; set; }
 
+    // The orientation value as known by BulletSim. Does not effect the physics engine.
     public virtual OMV.Quaternion RawOrientation { get; set; }
+    // Set orientation in BulletSim and the physics engine to a value immediately. Must be called at taint time.
     public abstract OMV.Quaternion ForceOrientation { get; set; }
 
+    // The velocity value as known by BulletSim. Does not effect the physics engine.
     public virtual OMV.Vector3 RawVelocity { get; set; }
+    // Set velocity in BulletSim and the physics engined to a value immediately. Must be called at taint time.
     public abstract OMV.Vector3 ForceVelocity { get; set; }
 
+    // The rotational velocity value as known by BulletSim. Does not effect the physics engine.
+    public OMV.Vector3 RawRotationalVelocity { get; set; }
+
+    // RawForce is a constant force applied to object (see Force { 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);
+        AddAngularForce(false, force);
     }
-    public abstract void AddAngularForce(OMV.Vector3 force, bool pushforce, bool inTaintTime);
-    public abstract void AddForce(OMV.Vector3 force, bool pushforce, bool inTaintTime);
+    public abstract void AddAngularForce(bool inTaintTime, OMV.Vector3 force);
+    public abstract void AddForce(bool inTaintTime, OMV.Vector3 force);
 
-    public abstract OMV.Vector3 ForceRotationalVelocity { get; set; }
+    // PhysicsActor.Velocity
+    public override OMV.Vector3 Velocity
+    {
+        get { return RawVelocity;  }
+        set
+        {
+            // This sets the velocity now. BSCharacter will override to clear target velocity
+            //    before calling this.
+            RawVelocity = value;
+            PhysScene.TaintedObject(LocalID, TypeName + ".SetVelocity", delegate () {
+                // DetailLog("{0},BSPhysObject.Velocity.set,vel={1}", LocalID, RawVelocity);
+                ForceVelocity = RawVelocity;
+            });
+        }
+    }
+
+    // PhysicsActor.SetMomentum
+    // All the physics engines use this as a way of forcing the velocity to something.
+    // BSCharacter overrides this so it can set the target velocity to zero before calling this.
+    public override void SetMomentum(OMV.Vector3 momentum)
+    {
+        this.Velocity = momentum;
+    }
+
+    public override OMV.Vector3 RotationalVelocity {
+        get {
+            return RawRotationalVelocity;
+        }
+        set {
+            RawRotationalVelocity = value;
+            Util.ClampV(RawRotationalVelocity, BSParam.MaxAngularVelocity);
+            // m_log.DebugFormat("{0}: RotationalVelocity={1}", LogHeader, _rotationalVelocity);
+            PhysScene.TaintedObject(LocalID, TypeName + ".setRotationalVelocity", delegate()
+            {
+                ForceRotationalVelocity = RawRotationalVelocity;
+            });
+        }
+    }
+    public OMV.Vector3 ForceRotationalVelocity {
+        get {
+            return RawRotationalVelocity;
+        }
+        set {
+            RawRotationalVelocity = Util.ClampV(value, BSParam.MaxAngularVelocity);
+            if (PhysBody.HasPhysicalBody)
+            {
+                DetailLog("{0},{1}.ForceRotationalVel,taint,rotvel={2}", LocalID, TypeName, RawRotationalVelocity);
+                PhysScene.PE.SetAngularVelocity(PhysBody, RawRotationalVelocity);
+                // PhysicsScene.PE.SetInterpolationAngularVelocity(PhysBody, _rotationalVelocity);
+                ActivateIfPhysical(false);
+            }
+        }
+    }
 
     public abstract float ForceBuoyancy { get; set; }
 
     public virtual bool ForceBodyShapeRebuild(bool inTaintTime) { return false; }
 
-    public override bool PIDActive 
+    public override bool PIDActive
     {
         get { return MoveToTargetActive; }
-        set { MoveToTargetActive = value; } 
+        set { MoveToTargetActive = value; }
     }
 
     public override OMV.Vector3 PIDTarget { set { MoveToTargetTarget = value; } }
@@ -268,7 +331,7 @@ public abstract class BSPhysObject : PhysicsActor
     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 bool PIDHoverActive {get {return HoverActive;}  set { HoverActive = value; } }
     public override float PIDHoverHeight { set { HoverHeight = value; } }
     public override PIDHoverType PIDHoverType { set { HoverType = value; } }
     public override float PIDHoverTau { set { HoverTau = value; } }
@@ -452,18 +515,24 @@ public abstract class BSPhysObject : PhysicsActor
     private long CollisionsLastTickStep = -1;
 
     // The simulation step is telling this object about a collision.
+    // I'm the 'collider', the thing I'm colliding with is the 'collidee'.
     // 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)
+    public virtual bool Collide(BSPhysObject collidee, OMV.Vector3 contactPoint, OMV.Vector3 contactNormal, float pentrationDepth)
     {
         bool ret = false;
 
+        // if 'collidee' is null, that means it is terrain
+        uint collideeLocalID = (collidee == null) ? BSScene.TERRAIN_ID : collidee.LocalID;
+        // All terrain goes by the TERRAIN_ID id when passed up as a collision
+        if (collideeLocalID <= PhysScene.TerrainManager.HighestTerrainID) {
+            collideeLocalID = BSScene.TERRAIN_ID;
+        }
+
         // The following lines make IsColliding(), CollidingGround() and CollidingObj work
         CollidingStep = PhysScene.SimulationStep;
-        if (collidingWith <= PhysScene.TerrainManager.HighestTerrainID)
+        if (collideeLocalID == BSScene.TERRAIN_ID)
         {
             CollidingGroundStep = PhysScene.SimulationStep;
         }
@@ -474,10 +543,13 @@ public abstract class BSPhysObject : PhysicsActor
 
         CollisionAccumulation++;
 
-        // For movement tests, remember if we are colliding with an object that is moving.
-        ColliderIsMoving = collidee != null ? (collidee.RawVelocity != OMV.Vector3.Zero) : false;
+        // For movement tests, if the collider is me, remember if we are colliding with an object that is moving.
+        // Here the 'collider'/'collidee' thing gets messed up. In the larger context, when something is checking
+        //     if the thing it is colliding with is moving, for instance, it asks if the its collider is moving.
+        ColliderIsMoving = collidee != null ? (collidee.RawVelocity != OMV.Vector3.Zero || collidee.RotationalVelocity != 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)
@@ -485,16 +557,29 @@ public abstract class BSPhysObject : PhysicsActor
             CollisionsLastTick = new CollisionEventUpdate();
             CollisionsLastTickStep = PhysScene.SimulationStep;
         }
-        CollisionsLastTick.AddCollider(collidingWith, new ContactPoint(contactPoint, contactNormal, pentrationDepth));
+        CollisionsLastTick.AddCollider(collideeLocalID, new ContactPoint(contactPoint, contactNormal, pentrationDepth));
 
         // If someone has subscribed for collision events log the collision so it will be reported up
         if (SubscribedEvents()) {
+            ContactPoint newContact = new ContactPoint(contactPoint, contactNormal, pentrationDepth);
+
+            // Collision sound requires a velocity to know it should happen. This is a lot of computation for a little used feature.
+            OMV.Vector3 relvel = OMV.Vector3.Zero;
+            if (IsPhysical)
+                relvel = RawVelocity;
+            if (collidee != null && collidee.IsPhysical)
+                relvel -= collidee.RawVelocity;
+            newContact.RelativeSpeed = -OMV.Vector3.Dot(relvel, contactNormal);
+            // DetailLog("{0},{1}.Collision.AddCollider,vel={2},contee.vel={3},relvel={4},relspeed={5}",
+            //         LocalID, TypeName, RawVelocity, (collidee == null ? OMV.Vector3.Zero : collidee.RawVelocity), relvel, newContact.RelativeSpeed);
+
             lock (PhysScene.CollisionLock)
             {
-                CollisionCollection.AddCollider(collidingWith, new ContactPoint(contactPoint, contactNormal, pentrationDepth));
+                CollisionCollection.AddCollider(collideeLocalID, newContact);
             }
-            DetailLog("{0},{1}.Collision.AddCollider,call,with={2},point={3},normal={4},depth={5},colliderMoving={6}",
-                            LocalID, TypeName, collidingWith, contactPoint, contactNormal, pentrationDepth, ColliderIsMoving);
+            DetailLog("{0},{1}.Collision.AddCollider,call,with={2},point={3},normal={4},depth={5},speed={6},colliderMoving={7}",
+                            LocalID, TypeName, collideeLocalID, contactPoint, contactNormal, pentrationDepth,
+                            newContact.RelativeSpeed, ColliderIsMoving);
 
             ret = true;
         }
@@ -555,7 +640,11 @@ public abstract class BSPhysObject : PhysicsActor
             PhysScene.TaintedObject(LocalID, TypeName+".SubscribeEvents", delegate()
             {
                 if (PhysBody.HasPhysicalBody)
+                {
                     CurrentCollisionFlags = PhysScene.PE.AddToCollisionFlags(PhysBody, CollisionFlags.BS_SUBSCRIBE_COLLISION_EVENTS);
+                    DetailLog("{0},{1}.SubscribeEvents,setting collision. ms={2}, collisionFlags={3:x}",
+                            LocalID, TypeName, SubscribedEventsMs, CurrentCollisionFlags);
+                }
             });
         }
         else
diff --git a/OpenSim/Region/PhysicsModules/BulletS/BSPrim.cs b/OpenSim/Region/PhysicsModules/BulletS/BSPrim.cs
index 6f27ac7..f085d70 100644
--- a/OpenSim/Region/PhysicsModules/BulletS/BSPrim.cs
+++ b/OpenSim/Region/PhysicsModules/BulletS/BSPrim.cs
@@ -33,7 +33,7 @@ using log4net;
 using OMV = OpenMetaverse;
 using OpenSim.Framework;
 using OpenSim.Region.PhysicsModules.SharedBase;
-using OpenSim.Region.PhysicsModule.ConvexDecompositionDotNet;
+using OpenSim.Region.PhysicsModules.ConvexDecompositionDotNet;
 
 namespace OpenSim.Region.PhysicsModule.BulletS
 {
@@ -59,7 +59,6 @@ public class BSPrim : BSPhysObject
     private bool _setAlwaysRun;
     private bool _throttleUpdates;
     private bool _floatOnWater;
-    private OMV.Vector3 _rotationalVelocity;
     private bool _kinematic;
     private float _buoyancy;
 
@@ -90,7 +89,7 @@ public class BSPrim : BSPhysObject
         RawOrientation = rotation;
         _buoyancy = 0f;
         RawVelocity = OMV.Vector3.Zero;
-        _rotationalVelocity = OMV.Vector3.Zero;
+        RawRotationalVelocity = OMV.Vector3.Zero;
         BaseShape = pbs;
         _isPhysical = pisPhysical;
         _isVolumeDetect = false;
@@ -256,7 +255,7 @@ public class BSPrim : BSPhysObject
     {
         RawVelocity = OMV.Vector3.Zero;
         _acceleration = OMV.Vector3.Zero;
-        _rotationalVelocity = OMV.Vector3.Zero;
+        RawRotationalVelocity = OMV.Vector3.Zero;
 
         // Zero some other properties in the physics engine
         PhysScene.TaintedObject(inTaintTime, LocalID, "BSPrim.ZeroMotion", delegate()
@@ -267,33 +266,33 @@ public class BSPrim : BSPhysObject
     }
     public override void ZeroAngularMotion(bool inTaintTime)
     {
-        _rotationalVelocity = OMV.Vector3.Zero;
+        RawRotationalVelocity = OMV.Vector3.Zero;
         // Zero some other properties in the physics engine
         PhysScene.TaintedObject(inTaintTime, LocalID, "BSPrim.ZeroMotion", delegate()
         {
             // DetailLog("{0},BSPrim.ZeroAngularMotion,call,rotVel={1}", LocalID, _rotationalVelocity);
             if (PhysBody.HasPhysicalBody)
             {
-                PhysScene.PE.SetInterpolationAngularVelocity(PhysBody, _rotationalVelocity);
-                PhysScene.PE.SetAngularVelocity(PhysBody, _rotationalVelocity);
+                PhysScene.PE.SetInterpolationAngularVelocity(PhysBody, RawRotationalVelocity);
+                PhysScene.PE.SetAngularVelocity(PhysBody, RawRotationalVelocity);
             }
         });
     }
 
-    public override void LockAngularMotion(OMV.Vector3 axis)
+    public override void LockAngularMotion(byte axislocks)
     {
-        DetailLog("{0},BSPrim.LockAngularMotion,call,axis={1}", LocalID, axis);
+        DetailLog("{0},BSPrim.LockAngularMotion,call,axis={1}", LocalID, axislocks);
 
         ApplyAxisLimits(ExtendedPhysics.PHYS_AXIS_UNLOCK_ANGULAR, 0f, 0f);
-        if (axis.X != 1)
+        if ((axislocks & 0x02) != 0)
         {
             ApplyAxisLimits(ExtendedPhysics.PHYS_AXIS_LOCK_ANGULAR_X, 0f, 0f);
         }
-        if (axis.Y != 1)
+        if ((axislocks & 0x04) != 0)
         {
             ApplyAxisLimits(ExtendedPhysics.PHYS_AXIS_LOCK_ANGULAR_Y, 0f, 0f);
         }
-        if (axis.Z != 1)
+        if ((axislocks & 0x08) != 0)
         {
             ApplyAxisLimits(ExtendedPhysics.PHYS_AXIS_LOCK_ANGULAR_Z, 0f, 0f);
         }
@@ -394,7 +393,7 @@ public class BSPrim : BSPhysObject
                 // Apply upforce and overcome gravity.
                 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);
+                AddForce(inTaintTime, correctionForce);
                 ret = true;
             }
         }
@@ -426,9 +425,9 @@ public class BSPrim : BSPhysObject
             RawVelocity = Util.ClampV(RawVelocity, BSParam.MaxLinearVelocity);
             ret = true;
         }
-        if (_rotationalVelocity.LengthSquared() > BSParam.MaxAngularVelocitySquared)
+        if (RawRotationalVelocity.LengthSquared() > BSParam.MaxAngularVelocitySquared)
         {
-            _rotationalVelocity = Util.ClampV(_rotationalVelocity, BSParam.MaxAngularVelocity);
+            RawRotationalVelocity = Util.ClampV(RawRotationalVelocity, BSParam.MaxAngularVelocity);
             ret = true;
         }
 
@@ -647,6 +646,59 @@ public class BSPrim : BSPhysObject
         });
     }
 
+    public override void SetVehicle(object pvdata)
+    {
+        PhysScene.TaintedObject(LocalID, "BSPrim.SetVehicle", delegate ()
+        {
+            BSDynamics vehicleActor = GetVehicleActor(true /* createIfNone */);
+            if (vehicleActor != null && (pvdata is VehicleData) )
+            {
+                VehicleData vdata = (VehicleData)pvdata;
+                // vehicleActor.ProcessSetVehicle((VehicleData)vdata);
+
+                vehicleActor.ProcessTypeChange(vdata.m_type);
+                vehicleActor.ProcessVehicleFlags(-1, false);
+                vehicleActor.ProcessVehicleFlags((int)vdata.m_flags, false);
+
+                // Linear properties
+                vehicleActor.ProcessVectorVehicleParam(Vehicle.LINEAR_MOTOR_DIRECTION, vdata.m_linearMotorDirection);
+                vehicleActor.ProcessVectorVehicleParam(Vehicle.LINEAR_FRICTION_TIMESCALE, vdata.m_linearFrictionTimescale);
+                vehicleActor.ProcessFloatVehicleParam(Vehicle.LINEAR_MOTOR_DECAY_TIMESCALE, vdata.m_linearMotorDecayTimescale);
+                vehicleActor.ProcessFloatVehicleParam(Vehicle.LINEAR_MOTOR_TIMESCALE, vdata.m_linearMotorTimescale);
+                vehicleActor.ProcessVectorVehicleParam(Vehicle.LINEAR_MOTOR_OFFSET, vdata.m_linearMotorOffset);
+
+                //Angular properties
+                vehicleActor.ProcessVectorVehicleParam(Vehicle.ANGULAR_MOTOR_DIRECTION, vdata.m_angularMotorDirection);
+                vehicleActor.ProcessFloatVehicleParam(Vehicle.ANGULAR_MOTOR_TIMESCALE, vdata.m_angularMotorTimescale);
+                vehicleActor.ProcessFloatVehicleParam(Vehicle.ANGULAR_MOTOR_DECAY_TIMESCALE, vdata.m_angularMotorDecayTimescale);
+                vehicleActor.ProcessVectorVehicleParam(Vehicle.ANGULAR_FRICTION_TIMESCALE, vdata.m_angularFrictionTimescale);
+
+                //Deflection properties
+                vehicleActor.ProcessFloatVehicleParam(Vehicle.ANGULAR_DEFLECTION_EFFICIENCY, vdata.m_angularDeflectionEfficiency);
+                vehicleActor.ProcessFloatVehicleParam(Vehicle.ANGULAR_DEFLECTION_TIMESCALE, vdata.m_angularDeflectionTimescale);
+                vehicleActor.ProcessFloatVehicleParam(Vehicle.LINEAR_DEFLECTION_EFFICIENCY, vdata.m_linearDeflectionEfficiency);
+                vehicleActor.ProcessFloatVehicleParam(Vehicle.LINEAR_DEFLECTION_TIMESCALE, vdata.m_linearDeflectionTimescale);
+
+                //Banking properties
+                vehicleActor.ProcessFloatVehicleParam(Vehicle.BANKING_EFFICIENCY, vdata.m_bankingEfficiency);
+                vehicleActor.ProcessFloatVehicleParam(Vehicle.BANKING_MIX, vdata.m_bankingMix);
+                vehicleActor.ProcessFloatVehicleParam(Vehicle.BANKING_TIMESCALE, vdata.m_bankingTimescale);
+
+                //Hover and Buoyancy properties
+                vehicleActor.ProcessFloatVehicleParam(Vehicle.HOVER_HEIGHT, vdata.m_VhoverHeight);
+                vehicleActor.ProcessFloatVehicleParam(Vehicle.HOVER_EFFICIENCY, vdata.m_VhoverEfficiency);
+                vehicleActor.ProcessFloatVehicleParam(Vehicle.HOVER_TIMESCALE, vdata.m_VhoverTimescale);
+                vehicleActor.ProcessFloatVehicleParam(Vehicle.BUOYANCY, vdata.m_VehicleBuoyancy);
+
+                //Attractor properties
+                vehicleActor.ProcessFloatVehicleParam(Vehicle.VERTICAL_ATTRACTION_EFFICIENCY, vdata.m_verticalAttractionEfficiency);
+                vehicleActor.ProcessFloatVehicleParam(Vehicle.VERTICAL_ATTRACTION_TIMESCALE, vdata.m_verticalAttractionTimescale);
+
+                vehicleActor.ProcessRotationVehicleParam(Vehicle.REFERENCE_FRAME, vdata.m_referenceFrame);
+            }
+        });
+    }
+
     // Allows the detection of collisions with inherently non-physical prims. see llVolumeDetect for more
     public override void SetVolumeDetect(int param) {
         bool newValue = (param != 0);
@@ -735,22 +787,9 @@ public class BSPrim : BSPhysObject
             }
         }
     }
-    public override OMV.Vector3 Velocity {
-        get { return RawVelocity; }
-        set {
-            RawVelocity = value;
-            PhysScene.TaintedObject(LocalID, "BSPrim.setVelocity", delegate()
-            {
-                // DetailLog("{0},BSPrim.SetVelocity,taint,vel={1}", LocalID, RawVelocity);
-                ForceVelocity = RawVelocity;
-            });
-        }
-    }
     public override OMV.Vector3 ForceVelocity {
         get { return RawVelocity; }
         set {
-            PhysScene.AssertInTaintTime("BSPrim.ForceVelocity");
-
             RawVelocity = Util.ClampV(value, BSParam.MaxLinearVelocity);
             if (PhysBody.HasPhysicalBody)
             {
@@ -955,7 +994,7 @@ public class BSPrim : BSPhysObject
             // For good measure, make sure the transform is set through to the motion state
             ForcePosition = RawPosition;
             ForceVelocity = RawVelocity;
-            ForceRotationalVelocity = _rotationalVelocity;
+            ForceRotationalVelocity = RawRotationalVelocity;
 
             // A dynamic object has mass
             UpdatePhysicalMassProperties(RawMass, false);
@@ -1075,35 +1114,6 @@ public class BSPrim : BSPhysObject
             });
         }
     }
-    public override OMV.Vector3 RotationalVelocity {
-        get {
-            return _rotationalVelocity;
-        }
-        set {
-            _rotationalVelocity = value;
-            Util.ClampV(_rotationalVelocity, BSParam.MaxAngularVelocity);
-            // m_log.DebugFormat("{0}: RotationalVelocity={1}", LogHeader, _rotationalVelocity);
-            PhysScene.TaintedObject(LocalID, "BSPrim.setRotationalVelocity", delegate()
-            {
-                ForceRotationalVelocity = _rotationalVelocity;
-            });
-        }
-    }
-    public override OMV.Vector3 ForceRotationalVelocity {
-        get {
-            return _rotationalVelocity;
-        }
-        set {
-            _rotationalVelocity = Util.ClampV(value, BSParam.MaxAngularVelocity);
-            if (PhysBody.HasPhysicalBody)
-            {
-                DetailLog("{0},BSPrim.ForceRotationalVel,taint,rotvel={1}", LocalID, _rotationalVelocity);
-                PhysScene.PE.SetAngularVelocity(PhysBody, _rotationalVelocity);
-                // PhysicsScene.PE.SetInterpolationAngularVelocity(PhysBody, _rotationalVelocity);
-                ActivateIfPhysical(false);
-            }
-        }
-    }
     public override bool Kinematic {
         get { return _kinematic; }
         set { _kinematic = value;
@@ -1132,14 +1142,14 @@ public class BSPrim : BSPhysObject
         }
     }
 
-    public override bool PIDActive 
+    public override bool PIDActive
     {
         get
         {
             return MoveToTargetActive;
         }
 
-        set 
+        set
         {
             MoveToTargetActive = value;
 
@@ -1167,12 +1177,16 @@ public class BSPrim : BSPhysObject
                 // 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 {
+        get
+        {
+        return base.HoverActive;
+        }
         set {
             base.HoverActive = value;
             EnableActor(HoverActive, HoverActorName, delegate()
@@ -1192,14 +1206,18 @@ public class BSPrim : BSPhysObject
         // 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 /= PhysScene.LastTimeStep;
-        AddForce(addForce, pushforce, false /* inTaintTime */);
+        // Push forces seem to be scaled differently (follow pattern in ubODE)
+        if (!pushforce) {
+            // Since this force is being applied in only one step, make this a force per second.
+            addForce /= PhysScene.LastTimeStep;
+        }
+
+        AddForce(false /* inTaintTime */, addForce);
     }
 
     // Applying a force just adds this to the total force on the object.
     // This added force will only last the next simulation tick.
-    public override void AddForce(OMV.Vector3 force, bool pushforce, bool inTaintTime) {
+    public override void AddForce(bool inTaintTime, OMV.Vector3 force) {
         // for an object, doesn't matter if force is a pushforce or not
         if (IsPhysicallyActive)
         {
@@ -1258,7 +1276,7 @@ public class BSPrim : BSPhysObject
     }
 
     // BSPhysObject.AddAngularForce()
-    public override void AddAngularForce(OMV.Vector3 force, bool pushforce, bool inTaintTime)
+    public override void AddAngularForce(bool inTaintTime, OMV.Vector3 force)
     {
         if (force.IsFinite())
         {
@@ -1297,9 +1315,6 @@ public class BSPrim : BSPhysObject
         });
     }
 
-    public override void SetMomentum(OMV.Vector3 momentum) {
-        // DetailLog("{0},BSPrim.SetMomentum,call,mom={1}", LocalID, momentum);
-    }
     #region Mass Calculation
 
     private float CalculateMass()
@@ -1869,7 +1884,7 @@ public class BSPrim : BSPhysObject
         if (entprop.Velocity == OMV.Vector3.Zero || !entprop.Velocity.ApproxEquals(RawVelocity, BSParam.UpdateVelocityChangeThreshold))
             RawVelocity = entprop.Velocity;
         _acceleration = entprop.Acceleration;
-        _rotationalVelocity = entprop.RotationalVelocity;
+        RawRotationalVelocity = entprop.RotationalVelocity;
 
         // DetailLog("{0},BSPrim.UpdateProperties,afterAssign,entprop={1}", LocalID, entprop);   // DEBUG DEBUG
 
@@ -1878,7 +1893,7 @@ public class BSPrim : BSPhysObject
         {
             entprop.Position = RawPosition;
             entprop.Velocity = RawVelocity;
-            entprop.RotationalVelocity = _rotationalVelocity;
+            entprop.RotationalVelocity = RawRotationalVelocity;
             entprop.Acceleration = _acceleration;
         }
 
diff --git a/OpenSim/Region/PhysicsModules/BulletS/BSPrimDisplaced.cs b/OpenSim/Region/PhysicsModules/BulletS/BSPrimDisplaced.cs
index d8ed56b..3f90fc5 100644..100755
--- a/OpenSim/Region/PhysicsModules/BulletS/BSPrimDisplaced.cs
+++ b/OpenSim/Region/PhysicsModules/BulletS/BSPrimDisplaced.cs
@@ -81,7 +81,6 @@ public class BSPrimDisplaced : BSPrim
     // Called at taint time.
     public virtual Vector3 SetEffectiveCenterOfMassDisplacement(Vector3 centerOfMassDisplacement)
     {
-        PhysScene.AssertInTaintTime("BSPrimDisplaced.SetEffectiveCenterOfMassDisplacement");
         Vector3 comDisp;
         if (UserSetCenterOfMassDisplacement.HasValue)
             comDisp = (OMV.Vector3)UserSetCenterOfMassDisplacement;
diff --git a/OpenSim/Region/PhysicsModules/BulletS/BSPrimLinkable.cs b/OpenSim/Region/PhysicsModules/BulletS/BSPrimLinkable.cs
index 55b5da0..563dcfa 100644..100755
--- a/OpenSim/Region/PhysicsModules/BulletS/BSPrimLinkable.cs
+++ b/OpenSim/Region/PhysicsModules/BulletS/BSPrimLinkable.cs
@@ -203,15 +203,14 @@ public class BSPrimLinkable : BSPrimDisplaced
     // Called after a simulation step to post a collision with this object.
     // This returns 'true' if the collision has been queued and the SendCollisions call must
     //     be made at the end of the simulation step.
-    public override bool Collide(uint collidingWith, BSPhysObject collidee,
-                    OMV.Vector3 contactPoint, OMV.Vector3 contactNormal, float pentrationDepth)
+    public override bool Collide(BSPhysObject collidee, OMV.Vector3 contactPoint, OMV.Vector3 contactNormal, float pentrationDepth)
     {
         bool ret = false;
         // Ask the linkset if it wants to handle the collision
-        if (!Linkset.HandleCollide(collidingWith, collidee, contactPoint, contactNormal, pentrationDepth))
+        if (!Linkset.HandleCollide(this, 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);
+            ret = base.Collide(collidee, contactPoint, contactNormal, pentrationDepth);
         }
         return ret;
     }
diff --git a/OpenSim/Region/PhysicsModules/BulletS/BSScene.cs b/OpenSim/Region/PhysicsModules/BulletS/BSScene.cs
index 452ce55..163efaa 100644
--- a/OpenSim/Region/PhysicsModules/BulletS/BSScene.cs
+++ b/OpenSim/Region/PhysicsModules/BulletS/BSScene.cs
@@ -124,9 +124,10 @@ namespace OpenSim.Region.PhysicsModule.BulletS
         // True if initialized and ready to do simulation steps
         private bool m_initialized = false;
 
-        // Flag which is true when processing taints.
-        // Not guaranteed to be correct all the time (don't depend on this) but good for debugging.
-        public bool InTaintTime { get; private set; }
+        // Object locked whenever execution is inside the physics engine
+        public Object PhysicsEngineLock = new object();
+        // Flag that is true when the simulator is active and shouldn't be touched
+        public bool InSimulationTime { get; private set; }
 
         // Pinned memory used to pass step information between managed and unmanaged
         internal int m_maxCollisionsPerFrame;
@@ -212,6 +213,11 @@ namespace OpenSim.Region.PhysicsModule.BulletS
             get { return "BulletSim"; }
         }
 
+        public string Version
+        {
+            get { return "1.0"; }
+        }
+
         public Type ReplaceableInterface
         {
             get { return null; }
@@ -245,6 +251,7 @@ namespace OpenSim.Region.PhysicsModule.BulletS
             EngineType = Name;
             RegionName = scene.RegionInfo.RegionName;
             PhysicsSceneName = EngineType + "/" + RegionName;
+            EngineName = Name + " " + Version;
 
             scene.RegisterModuleInterface<PhysicsScene>(this);
             Vector3 extent = new Vector3(scene.RegionInfo.RegionSizeX, scene.RegionInfo.RegionSizeY, scene.RegionInfo.RegionSizeZ);
@@ -338,19 +345,19 @@ namespace OpenSim.Region.PhysicsModule.BulletS
             // Put some informational messages into the log file.
             m_log.InfoFormat("{0} Linksets implemented with {1}", LogHeader, (BSLinkset.LinksetImplementation)BSParam.LinksetImplementation);
 
-            InTaintTime = false;
+            InSimulationTime = 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 
+                m_physicsThread
                     = WorkManager.StartThread(
-                        BulletSPluginPhysicsThread, 
-                        string.Format("{0} ({1})", BulletEngineName, RegionName), 
-                        ThreadPriority.Normal, 
-                        true, 
+                        BulletSPluginPhysicsThread,
+                        string.Format("{0} ({1})", BulletEngineName, RegionName),
+                        ThreadPriority.Normal,
+                        true,
                         true);
             }
         }
@@ -523,13 +530,13 @@ namespace OpenSim.Region.PhysicsModule.BulletS
             return null;
         }
 
-        public override PhysicsActor AddAvatar(uint localID, string avName, Vector3 position, Vector3 velocity, Vector3 size, bool isFlying)
+        public override PhysicsActor AddAvatar(uint localID, string avName, Vector3 position, Vector3 size, float footOffset, bool isFlying)
         {
             // m_log.DebugFormat("{0}: AddAvatar: {1}", LogHeader, avName);
 
             if (!m_initialized) return null;
 
-            BSCharacter actor = new BSCharacter(localID, avName, this, position, velocity, size, isFlying);
+            BSCharacter actor = new BSCharacter(localID, avName, this, position, Vector3.Zero, size, footOffset, isFlying);
             lock (PhysObjects)
                 PhysObjects.Add(localID, actor);
 
@@ -651,49 +658,57 @@ namespace OpenSim.Region.PhysicsModule.BulletS
 
             int beforeTime = Util.EnvironmentTickCount();
             int simTime = 0;
+            int numTaints = 0;
+            int numSubSteps = 0;
 
-            int numTaints = _taintOperations.Count;
-            InTaintTime = true; // Only used for debugging so locking is not necessary.
+            lock (PhysicsEngineLock)
+            {
+                InSimulationTime = true;
+                // update the prim states while we know the physics engine is not busy
+                numTaints += ProcessTaints();
 
-            // update the prim states while we know the physics engine is not busy
-            ProcessTaints();
+                // Some of the physical objects requre individual, pre-step calls
+                //      (vehicles and avatar movement, in particular)
+                TriggerPreStepEvent(timeStep);
 
-            // Some of the physical objects requre individual, pre-step calls
-            //      (vehicles and avatar movement, in particular)
-            TriggerPreStepEvent(timeStep);
+                // the prestep actions might have added taints
+                numTaints += ProcessTaints();
 
-            // the prestep actions might have added taints
-            numTaints += _taintOperations.Count;
-            ProcessTaints();
+                // 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)
+                    PE.DumpAllInfo(World);
 
-            InTaintTime = false; // Only used for debugging so locking is not necessary.
+                // step the physical world one interval
+                m_simulationStep++;
+                try
+                {
+                    numSubSteps = PE.PhysicsStep(World, timeStep, m_maxSubSteps, m_fixedTimeStep, out updatedEntityCount, out collidersCount);
+                }
+                catch (Exception e)
+                {
+                    m_log.WarnFormat("{0},PhysicsStep Exception: nTaints={1}, substeps={2}, updates={3}, colliders={4}, e={5}",
+                                LogHeader, numTaints, numSubSteps, updatedEntityCount, collidersCount, e);
+                    DetailLog("{0},PhysicsStepException,call, nTaints={1}, substeps={2}, updates={3}, colliders={4}",
+                                DetailLogZero, numTaints, numSubSteps, updatedEntityCount, collidersCount);
+                    updatedEntityCount = 0;
+                    collidersCount = 0;
+                }
 
-            // 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)
-                PE.DumpAllInfo(World);
+                // Make the physics engine dump useful statistics periodically
+                if (PhysicsMetricDumpFrames != 0 && ((m_simulationStep % PhysicsMetricDumpFrames) == 0))
+                    PE.DumpPhysicsStatistics(World);
 
-            // step the physical world one interval
-            m_simulationStep++;
-            int numSubSteps = 0;
-            try
-            {
-                numSubSteps = PE.PhysicsStep(World, timeStep, m_maxSubSteps, m_fixedTimeStep, out updatedEntityCount, out collidersCount);
+                InSimulationTime = false;
 
-            }
-            catch (Exception e)
-            {
-                m_log.WarnFormat("{0},PhysicsStep Exception: nTaints={1}, substeps={2}, updates={3}, colliders={4}, e={5}",
-                            LogHeader, numTaints, numSubSteps, updatedEntityCount, collidersCount, e);
-                DetailLog("{0},PhysicsStepException,call, nTaints={1}, substeps={2}, updates={3}, colliders={4}",
-                            DetailLogZero, numTaints, numSubSteps, updatedEntityCount, collidersCount);
-                updatedEntityCount = 0;
-                collidersCount = 0;
-            }
+                // Some actors want to know when the simulation step is complete.
+                TriggerPostStepEvent(timeStep);
+
+                // In case there were any parameter updates that happened during the simulation step
+                numTaints += ProcessTaints();
 
-            // Make the physics engine dump useful statistics periodically
-            if (PhysicsMetricDumpFrames != 0 && ((m_simulationStep % PhysicsMetricDumpFrames) == 0))
-                PE.DumpPhysicsStatistics(World);
+                InSimulationTime = false;
+            }
 
             // Get a value for 'now' so all the collision and update routines don't have to get their own.
             SimulationNowTime = Util.EnvironmentTickCount();
@@ -743,9 +758,6 @@ namespace OpenSim.Region.PhysicsModule.BulletS
                 }
             }
 
-            // Some actors want to know when the simulation step is complete.
-            TriggerPostStepEvent(timeStep);
-
             simTime = Util.EnvironmentTickCountSubtract(beforeTime);
             if (PhysicsLogging.Enabled)
             {
@@ -762,7 +774,8 @@ namespace OpenSim.Region.PhysicsModule.BulletS
             // 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).
-            m_simulatedTime +=  (float)numSubSteps * m_fixedTimeStep * 1000f * NominalFrameRate;
+//            m_simulatedTime +=  (float)numSubSteps * m_fixedTimeStep * 1000f * NominalFrameRate;
+            m_simulatedTime +=  (float)numSubSteps * m_fixedTimeStep;
         }
 
         // Called by a BSPhysObject to note that it has changed properties and this information
@@ -849,7 +862,7 @@ namespace OpenSim.Region.PhysicsModule.BulletS
 
             // 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;
+            float simTime = m_simulatedTime / timeStep;
             m_simulatedTime = 0f;
             return simTime;
         }
@@ -879,7 +892,7 @@ namespace OpenSim.Region.PhysicsModule.BulletS
 
             if (collider.IsInitialized)
             {
-                if (collider.Collide(collidingWith, collidee, collidePoint, collideNormal, penetration))
+                if (collider.Collide(collidee, collidePoint, collideNormal, penetration))
                 {
                     // If a collision was 'good', remember to send it to the simulator
                     lock (CollisionLock)
@@ -948,26 +961,150 @@ namespace OpenSim.Region.PhysicsModule.BulletS
             // m_log.DebugFormat("{0}: DeleteTerrain()", LogHeader);
         }
 
-        // Although no one seems to check this, I do support combining.
-        public override bool SupportsCombining()
+        #endregion // Terrain
+
+        #region Raycast
+
+        public override bool SupportsRayCast()
         {
-            return TerrainManager.SupportsCombining();
+            return BSParam.UseBulletRaycast;
         }
-        // This call says I am a child to region zero in a mega-region. 'pScene' is that
-        //    of region zero, 'offset' is my offset from regions zero's origin, and
-        //    'extents' is the largest XY that is handled in my region.
-        public override void Combine(PhysicsScene pScene, Vector3 offset, Vector3 extents)
+
+        public override bool SupportsRaycastWorldFiltered()
         {
-            TerrainManager.Combine(pScene, offset, extents);
+            return BSParam.UseBulletRaycast;
         }
 
-        // Unhook all the combining that I know about.
-        public override void UnCombine(PhysicsScene pScene)
+
+        /// <summary>
+        /// Queue a raycast against the physics scene.
+        /// The provided callback method will be called when the raycast is complete
+        ///
+        /// Many physics engines don't support collision testing at the same time as
+        /// manipulating the physics scene, so we queue the request up and callback
+        /// a custom method when the raycast is complete.
+        /// This allows physics engines that give an immediate result to callback immediately
+        /// and ones that don't, to callback when it gets a result back.
+        ///      public delegate void RayCallback(List<ContactResult> list);
+        ///
+        /// ODE for example will not allow you to change the scene while collision testing or
+        /// it asserts, 'opteration not valid for locked space'.  This includes adding a ray to the scene.
+        ///
+        /// This is named RayCastWorld to not conflict with modrex's Raycast method.
+        /// </summary>
+        /// <param name="position">Origin of the ray</param>
+        /// <param name="direction">Direction of the ray</param>
+        /// <param name="length">Length of ray in meters</param>
+        /// <param name="retMethod">Method to call when the raycast is complete</param>
+        public override void RaycastWorld(Vector3 position, Vector3 direction, float length, RaycastCallback retMethod)
         {
-            TerrainManager.UnCombine(pScene);
+            if (retMethod != null)
+            {
+                if (BSParam.UseBulletRaycast)
+                {
+                    Vector3 posFrom = position;
+                    Vector3 posTo = Vector3.Normalize(direction) * length + position;
+
+                    TaintedObject(DetailLogZero, "BSScene.RaycastWorld1", delegate ()
+                    {
+                        RaycastHit hitInfo = PE.RayTest2(World, posFrom, posTo, 0xffff, 0xffff);
+                        retMethod(true, hitInfo.Point, hitInfo.ID, hitInfo.Fraction, hitInfo.Normal);
+                    });
+                }
+                else
+                {
+                    retMethod(false, Vector3.Zero, 0, 999999999999f, Vector3.Zero);
+                }
+            }
         }
 
-        #endregion // Terrain
+        public override void RaycastWorld(Vector3 position, Vector3 direction, float length, int count, RayCallback retMethod)
+        {
+            if (retMethod != null)
+            {
+                if (BSParam.UseBulletRaycast)
+                {
+                    List<ContactResult> hitInfo = RaycastWorld(position, direction, length, count);
+                    retMethod(hitInfo);
+                }
+                else
+                {
+                    retMethod(new List<ContactResult>());
+                }
+            }
+        }
+
+        public override List<ContactResult> RaycastWorld(Vector3 position, Vector3 direction, float length, int count)
+        {
+            return (List<ContactResult>)RaycastWorld(position, direction, length, count, RayFilterFlags.All);
+        }
+
+        public override object RaycastWorld(Vector3 position, Vector3 direction, float length, int count, RayFilterFlags filter)
+        {
+            List<ContactResult> ret = new List<ContactResult>();
+            if (BSParam.UseBulletRaycast)
+            {
+                uint collisionFilter = 0;
+                uint collisionMask = 0;
+                if ((filter & RayFilterFlags.land) != 0)
+                {
+                    collisionFilter |= BulletSimData.CollisionTypeMasks[CollisionType.Terrain].group;
+                    collisionMask |= BulletSimData.CollisionTypeMasks[CollisionType.Terrain].mask;
+                }
+                if ((filter & RayFilterFlags.agent) != 0)
+                {
+                    collisionFilter |= BulletSimData.CollisionTypeMasks[CollisionType.Avatar].group;
+                    collisionMask |= BulletSimData.CollisionTypeMasks[CollisionType.Avatar].mask;
+                }
+                if ((filter & RayFilterFlags.nonphysical) != 0)
+                {
+                    collisionFilter |= BulletSimData.CollisionTypeMasks[CollisionType.Static].group;
+                    collisionMask |= BulletSimData.CollisionTypeMasks[CollisionType.Static].mask;
+                }
+                if ((filter & RayFilterFlags.physical) != 0)
+                {
+                    collisionFilter |= BulletSimData.CollisionTypeMasks[CollisionType.Dynamic].group;
+                    collisionMask |= BulletSimData.CollisionTypeMasks[CollisionType.Dynamic].mask;
+                }
+                // if ((filter & RayFilterFlags.phantom) != 0)
+                // {
+                //     collisionFilter |= BulletSimData.CollisionTypeMasks[CollisionType.VolumeDetect].group;
+                //     collisionMask |= BulletSimData.CollisionTypeMasks[CollisionType.VolumeDetect].mask;
+                // }
+                if ((filter & RayFilterFlags.volumedtc) != 0)
+                {
+                    collisionFilter |= BulletSimData.CollisionTypeMasks[CollisionType.VolumeDetect].group;
+                    collisionMask |= BulletSimData.CollisionTypeMasks[CollisionType.VolumeDetect].mask;
+                }
+                DetailLog("{0},RaycastWorld,pos={1},dir={2},len={3},count={4},filter={5},filter={6},mask={7}",
+                        DetailLogZero, position, direction, length, count, filter, collisionFilter, collisionMask);
+                // NOTE: locking ensures the physics engine is not executing.
+                //    The caller might have to wait for the physics engine to finish.
+                lock (PhysicsEngineLock)
+                {
+                    Vector3 posFrom = position;
+                    Vector3 posTo = Vector3.Normalize(direction) * length + position;
+                    DetailLog("{0},RaycastWorld,RayTest2,from={1},to={2}",
+                                DetailLogZero, posFrom, posTo);
+                    RaycastHit hitInfo = PE.RayTest2(World, posFrom, posTo, collisionFilter, collisionMask);
+                    if (hitInfo.hasHit())
+                    {
+                        ContactResult result = new ContactResult();
+                        result.Pos = hitInfo.Point;
+                        result.Normal = hitInfo.Normal;
+                        result.ConsumerID = hitInfo.ID;
+                        result.Depth = hitInfo.Fraction;
+                        ret.Add(result);
+                        DetailLog("{0},RaycastWorld,hit,pos={1},norm={2},depth={3},id={4}",
+                            DetailLogZero, result.Pos, result.Normal, result.Depth, result.ConsumerID);
+                    }
+                }
+            }
+            return ret;
+        }
+
+        #endregion Raycast
+
 
         public override Dictionary<uint, float> GetTopColliders()
         {
@@ -1081,32 +1218,35 @@ namespace OpenSim.Region.PhysicsModule.BulletS
         // 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 pOriginator, string pIdent, TaintCallback pCallback)
+        // NOTE: 'inTaintTime' is no longer used. This entry exists so all the calls don't have to be changed.
+        // public void TaintedObject(bool inTaintTime, String pIdent, TaintCallback pCallback)
+        // {
+        //     TaintedObject(BSScene.DetailLogZero, pIdent, pCallback);
+        // }
+        // NOTE: 'inTaintTime' is no longer used. This entry exists so all the calls don't have to be changed.
+        public void TaintedObject(bool inTaintTime, uint pOriginator, String pIdent, TaintCallback pCallback)
         {
-            TaintedObject(false /*inTaintTime*/, pOriginator, pIdent, pCallback);
+            TaintedObject(m_physicsLoggingEnabled ? pOriginator.ToString() : BSScene.DetailLogZero, 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);
+            TaintedObject(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 pOriginator, string pIdent, TaintCallback pCallback)
+        public void TaintedObject(string pOriginator, string pIdent, TaintCallback pCallback)
         {
             if (!m_initialized) return;
 
-            if (inTaintTime)
+            if (Monitor.TryEnter(PhysicsEngineLock))
+            {
+                // If we can get exclusive access to the physics engine, just do the operation
                 pCallback();
+                Monitor.Exit(PhysicsEngineLock);
+            }
             else
             {
+                // The physics engine is busy, queue the operation
                 lock (_taintLock)
                 {
                     _taintOperations.Add(new TaintCallbackEntry(pOriginator, pIdent, pCallback));
@@ -1133,14 +1273,21 @@ namespace OpenSim.Region.PhysicsModule.BulletS
         // When someone tries to change a property on a BSPrim or BSCharacter, the object queues
         // a callback into itself to do the actual property change. That callback is called
         // here just before the physics engine is called to step the simulation.
-        public void ProcessTaints()
+        // Returns the number of taints processed
+        // NOTE: Called while PhysicsEngineLock is locked
+        public int ProcessTaints()
         {
-            ProcessRegularTaints();
-            ProcessPostTaintTaints();
+            int ret = 0;
+            ret += ProcessRegularTaints();
+            ret += ProcessPostTaintTaints();
+            return ret;
         }
 
-        private void ProcessRegularTaints()
+        // Returns the number of taints processed
+        // NOTE: Called while PhysicsEngineLock is locked
+        private int ProcessRegularTaints()
         {
+            int ret = 0;
             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
@@ -1157,6 +1304,7 @@ namespace OpenSim.Region.PhysicsModule.BulletS
                     {
                         DetailLog("{0},BSScene.ProcessTaints,doTaint,id={1}", tcbe.originator, tcbe.ident); // DEBUG DEBUG DEBUG
                         tcbe.callback();
+                        ret++;
                     }
                     catch (Exception e)
                     {
@@ -1165,6 +1313,7 @@ namespace OpenSim.Region.PhysicsModule.BulletS
                 }
                 oldList.Clear();
             }
+            return ret;
         }
 
         // Schedule an update to happen after all the regular taints are processed.
@@ -1183,8 +1332,11 @@ namespace OpenSim.Region.PhysicsModule.BulletS
         }
 
         // Taints that happen after the normal taint processing but before the simulation step.
-        private void ProcessPostTaintTaints()
+        // Returns the number of taints processed
+        // NOTE: Called while PhysicsEngineLock is locked
+        private int ProcessPostTaintTaints()
         {
+            int ret = 0;
             if (m_initialized && _postTaintOperations.Count > 0)
             {
                 Dictionary<string, TaintCallbackEntry> oldList;
@@ -1200,6 +1352,7 @@ namespace OpenSim.Region.PhysicsModule.BulletS
                     {
                         DetailLog("{0},BSScene.ProcessPostTaintTaints,doTaint,id={1}", DetailLogZero, kvp.Key); // DEBUG DEBUG DEBUG
                         kvp.Value.callback();
+                        ret++;
                     }
                     catch (Exception e)
                     {
@@ -1208,20 +1361,8 @@ namespace OpenSim.Region.PhysicsModule.BulletS
                 }
                 oldList.Clear();
             }
+            return ret;
         }
-
-        // Only used for debugging. Does not change state of anything so locking is not necessary.
-        public bool AssertInTaintTime(string whereFrom)
-        {
-            if (!InTaintTime)
-            {
-                DetailLog("{0},BSScene.AssertInTaintTime,NOT IN TAINT TIME,Region={1},Where={2}", DetailLogZero, RegionName, whereFrom);
-                m_log.ErrorFormat("{0} NOT IN TAINT TIME!! Region={1}, Where={2}", LogHeader, RegionName, whereFrom);
-                // Util.PrintCallStack(DetailLog);
-            }
-            return InTaintTime;
-        }
-
         #endregion // Taints
 
         #region IPhysicsParameters
diff --git a/OpenSim/Region/PhysicsModules/BulletS/BSShapeCollection.cs b/OpenSim/Region/PhysicsModules/BulletS/BSShapeCollection.cs
index b100273..86bf23f 100644..100755
--- a/OpenSim/Region/PhysicsModules/BulletS/BSShapeCollection.cs
+++ b/OpenSim/Region/PhysicsModules/BulletS/BSShapeCollection.cs
@@ -30,7 +30,6 @@ using System.Text;
 using OMV = OpenMetaverse;
 using OpenSim.Framework;
 using OpenSim.Region.PhysicsModules.SharedBase;
-using OpenSim.Region.PhysicsModule.ConvexDecompositionDotNet;
 
 namespace OpenSim.Region.PhysicsModule.BulletS
 {
@@ -76,8 +75,6 @@ public sealed class BSShapeCollection : IDisposable
     // Called at taint-time.
     public bool GetBodyAndShape(bool forceRebuild, BulletWorld sim, BSPhysObject prim, PhysicalDestructionCallback bodyCallback)
     {
-        m_physicsScene.AssertInTaintTime("BSShapeCollection.GetBodyAndShape");
-
         bool ret = false;
 
         // This lock could probably be pushed down lower but building shouldn't take long
@@ -230,6 +227,8 @@ public sealed class BSShapeCollection : IDisposable
             ret = CreateGeomMeshOrHull(prim, shapeCallback);
         }
 
+        m_physicsScene.PE.ResetBroadphasePool(m_physicsScene.World);    // DEBUG DEBUG
+
         return ret;
     }
 
@@ -345,8 +344,6 @@ public sealed class BSShapeCollection : IDisposable
         if (!body.HasPhysicalBody)
             return;
 
-        m_physicsScene.AssertInTaintTime("BSShapeCollection.DereferenceBody");
-
         lock (m_collectionActivityLock)
         {
             if (DDetail) DetailLog("{0},BSShapeCollection.DereferenceBody,DestroyingBody,body={1}", body.ID, body);
diff --git a/OpenSim/Region/PhysicsModules/BulletS/BSShapes.cs b/OpenSim/Region/PhysicsModules/BulletS/BSShapes.cs
index 086a412..e791b27 100644..100755
--- a/OpenSim/Region/PhysicsModules/BulletS/BSShapes.cs
+++ b/OpenSim/Region/PhysicsModules/BulletS/BSShapes.cs
@@ -31,8 +31,8 @@ using System.Text;
 
 using OpenSim.Framework;
 using OpenSim.Region.PhysicsModules.SharedBase;
-using OpenSim.Region.PhysicsModules.Meshing;
-using OpenSim.Region.PhysicsModule.ConvexDecompositionDotNet;
+using OpenSim.Region.PhysicsModule.Meshing;
+using OpenSim.Region.PhysicsModules.ConvexDecompositionDotNet;
 
 using OMV = OpenMetaverse;
 
@@ -555,7 +555,9 @@ public class BSShapeMesh : BSShape
         {
             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,   // do not cache the mesh and do not use previously built versions
+                                            false,
+                                            false
                                             );
         }
 
@@ -712,7 +714,7 @@ public class BSShapeHull : BSShape
         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 */);
+            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)
diff --git a/OpenSim/Region/PhysicsModules/BulletS/BSTerrainHeightmap.cs b/OpenSim/Region/PhysicsModules/BulletS/BSTerrainHeightmap.cs
index 42fc11b..f72ad28 100644..100755
--- a/OpenSim/Region/PhysicsModules/BulletS/BSTerrainHeightmap.cs
+++ b/OpenSim/Region/PhysicsModules/BulletS/BSTerrainHeightmap.cs
@@ -141,14 +141,30 @@ public sealed class BSTerrainHeightmap : BSTerrainPhys
     }
 
     // The passed position is relative to the base of the region.
+    // There are many assumptions herein that the heightmap increment is 1.
     public override float GetTerrainHeightAtXYZ(Vector3 pos)
     {
         float ret = BSTerrainManager.HEIGHT_GETHEIGHT_RET;
 
-        int mapIndex = (int)pos.Y * (int)m_mapInfo.sizeY + (int)pos.X;
-        try
-        {
-            ret = m_mapInfo.heightMap[mapIndex];
+        try {
+            int baseX = (int)pos.X;
+            int baseY = (int)pos.Y;
+            int maxX = (int)m_mapInfo.sizeX;
+            int maxY = (int)m_mapInfo.sizeY;
+            float diffX = pos.X - (float)baseX;
+            float diffY = pos.Y - (float)baseY;
+
+            float mapHeight1 = m_mapInfo.heightMap[baseY * maxY + baseX];
+            float mapHeight2 = m_mapInfo.heightMap[Math.Min(baseY + 1, maxY - 1) * maxY + baseX];
+            float mapHeight3 = m_mapInfo.heightMap[baseY * maxY + Math.Min(baseX + 1, maxX  - 1)];
+            float mapHeight4 = m_mapInfo.heightMap[Math.Min(baseY + 1, maxY - 1) * maxY +  Math.Min(baseX + 1, maxX  - 1)];
+
+            float Xrise = (mapHeight4 - mapHeight3) * diffX;
+            float Yrise = (mapHeight2 - mapHeight1) * diffY;
+
+            ret = mapHeight1 + ((Xrise + Yrise) / 2f);
+            // m_physicsScene.DetailLog("{0},BSTerrainHeightMap,GetTerrainHeightAtXYZ,pos={1},{2}/{3}/{4}/{5},ret={6}",
+            //         BSScene.DetailLogZero, pos, mapHeight1, mapHeight2, mapHeight3, mapHeight4, ret);
         }
         catch
         {
diff --git a/OpenSim/Region/PhysicsModules/BulletS/BSTerrainManager.cs b/OpenSim/Region/PhysicsModules/BulletS/BSTerrainManager.cs
index d11baa6..d11baa6 100644..100755
--- a/OpenSim/Region/PhysicsModules/BulletS/BSTerrainManager.cs
+++ b/OpenSim/Region/PhysicsModules/BulletS/BSTerrainManager.cs
diff --git a/OpenSim/Region/PhysicsModules/BulletS/BSTerrainMesh.cs b/OpenSim/Region/PhysicsModules/BulletS/BSTerrainMesh.cs
index cd59b65..cd59b65 100644..100755
--- a/OpenSim/Region/PhysicsModules/BulletS/BSTerrainMesh.cs
+++ b/OpenSim/Region/PhysicsModules/BulletS/BSTerrainMesh.cs
diff --git a/OpenSim/Region/PhysicsModules/BulletS/BulletSimData.cs b/OpenSim/Region/PhysicsModules/BulletS/BulletSimData.cs
index 3329395..308769b 100644..100755
--- a/OpenSim/Region/PhysicsModules/BulletS/BulletSimData.cs
+++ b/OpenSim/Region/PhysicsModules/BulletS/BulletSimData.cs
@@ -100,6 +100,7 @@ public class BulletBody
     }
 }
 
+// Handle to btCollisionObject - a shape that can be added to a btRidgidBody
 public class BulletShape
 {
     public BulletShape()
diff --git a/OpenSim/Region/PhysicsModules/BulletS/BulletSimTODO.txt b/OpenSim/Region/PhysicsModules/BulletS/BulletSimTODO.txt
index 0453376..0453376 100644..100755
--- a/OpenSim/Region/PhysicsModules/BulletS/BulletSimTODO.txt
+++ b/OpenSim/Region/PhysicsModules/BulletS/BulletSimTODO.txt
diff --git a/OpenSim/Region/PhysicsModules/BulletS/ExtendedPhysics.cs b/OpenSim/Region/PhysicsModules/BulletS/ExtendedPhysics.cs
index 2ba3c5a..ab5d4849 100644..100755
--- a/OpenSim/Region/PhysicsModules/BulletS/ExtendedPhysics.cs
+++ b/OpenSim/Region/PhysicsModules/BulletS/ExtendedPhysics.cs
@@ -136,7 +136,7 @@ namespace OpenSim.Region.PhysicsModule.BulletS
 
                 return;
             }
- 
+
             // Register as LSL functions all the [ScriptInvocation] marked methods.
             Comms.RegisterScriptInvocations(this);
             Comms.RegisterConstants(this);
diff --git a/OpenSim/Region/PhysicsModules/BulletS/Properties/AssemblyInfo.cs b/OpenSim/Region/PhysicsModules/BulletS/Properties/AssemblyInfo.cs
index 698be39..91ce468 100644
--- a/OpenSim/Region/PhysicsModules/BulletS/Properties/AssemblyInfo.cs
+++ b/OpenSim/Region/PhysicsModules/BulletS/Properties/AssemblyInfo.cs
@@ -3,7 +3,7 @@ using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 using Mono.Addins;
 
-// General Information about an assembly is controlled through the following 
+// General Information about an assembly is controlled through the following
 // set of attributes. Change these attribute values to modify the information
 // associated with an assembly.
 [assembly: AssemblyTitle("OpenSim.Region.Physics.BulletSPlugin")]
@@ -15,8 +15,8 @@ using Mono.Addins;
 [assembly: AssemblyTrademark("")]
 [assembly: AssemblyCulture("")]
 
-// Setting ComVisible to false makes the types in this assembly not visible 
-// to COM components.  If you need to access a type in this assembly from 
+// Setting ComVisible to false makes the types in this assembly not visible
+// to COM components.  If you need to access a type in this assembly from
 // COM, set the ComVisible attribute to true on that type.
 [assembly: ComVisible(false)]
 
@@ -26,11 +26,11 @@ using Mono.Addins;
 // Version information for an assembly consists of the following four values:
 //
 //      Major Version
-//      Minor Version 
+//      Minor Version
 //      Build Number
 //      Revision
 //
-[assembly: AssemblyVersion("0.8.3.*")]
+[assembly: AssemblyVersion(OpenSim.VersionInfo.AssemblyVersionNumber)]
 
 [assembly: Addin("OpenSim.Region.PhysicsModule.BulletS", OpenSim.VersionInfo.VersionNumber)]
 [assembly: AddinDependency("OpenSim.Region.Framework", OpenSim.VersionInfo.VersionNumber)]
diff --git a/OpenSim/Region/PhysicsModules/BulletS/Tests/BasicVehicles.cs b/OpenSim/Region/PhysicsModules/BulletS/Tests/BasicVehicles.cs
index 35eba29..35eba29 100644..100755
--- a/OpenSim/Region/PhysicsModules/BulletS/Tests/BasicVehicles.cs
+++ b/OpenSim/Region/PhysicsModules/BulletS/Tests/BasicVehicles.cs
diff --git a/OpenSim/Region/PhysicsModules/BulletS/Tests/BulletSimTests.cs b/OpenSim/Region/PhysicsModules/BulletS/Tests/BulletSimTests.cs
index 0be1f4c..14d0bdc 100644..100755
--- a/OpenSim/Region/PhysicsModules/BulletS/Tests/BulletSimTests.cs
+++ b/OpenSim/Region/PhysicsModules/BulletS/Tests/BulletSimTests.cs
@@ -1,56 +1,56 @@
-/*

- * 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 copyright

- *       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 NUnit.Framework;

-using log4net;

-

-using OpenSim.Tests.Common;

-

-namespace OpenSim.Region.PhysicsModule.BulletS.Tests

-{

-[TestFixture]

-public class BulletSimTests : OpenSimTestCase

-{

-    // Documentation on attributes: http://www.nunit.org/index.php?p=attributes&r=2.6.1

-    // Documentation on assertions: http://www.nunit.org/index.php?p=assertions&r=2.6.1

-

-    [TestFixtureSetUp]

-    public void Init()

-    {

-    }

-

-    [TestFixtureTearDown]

-    public void TearDown()

-    {

-    }

-}

-}

+/*
+ * 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 copyright
+ *       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 NUnit.Framework;
+using log4net;
+
+using OpenSim.Tests.Common;
+
+namespace OpenSim.Region.PhysicsModule.BulletS.Tests
+{
+[TestFixture]
+public class BulletSimTests : OpenSimTestCase
+{
+    // Documentation on attributes: http://www.nunit.org/index.php?p=attributes&r=2.6.1
+    // Documentation on assertions: http://www.nunit.org/index.php?p=assertions&r=2.6.1
+
+    [TestFixtureSetUp]
+    public void Init()
+    {
+    }
+
+    [TestFixtureTearDown]
+    public void TearDown()
+    {
+    }
+}
+}
diff --git a/OpenSim/Region/PhysicsModules/BulletS/Tests/BulletSimTestsUtil.cs b/OpenSim/Region/PhysicsModules/BulletS/Tests/BulletSimTestsUtil.cs
index 4eeea4d..3e8c1cd 100644..100755
--- a/OpenSim/Region/PhysicsModules/BulletS/Tests/BulletSimTestsUtil.cs
+++ b/OpenSim/Region/PhysicsModules/BulletS/Tests/BulletSimTestsUtil.cs
@@ -34,7 +34,7 @@ using Nini.Config;
 
 using OpenSim.Framework;
 using OpenSim.Region.PhysicsModules.SharedBase;
-using OpenSim.Region.PhysicsModules.Meshing;
+using OpenSim.Region.PhysicsModule.Meshing;
 using OpenSim.Region.Framework.Interfaces;
 
 using OpenMetaverse;
@@ -80,13 +80,13 @@ public static class BulletSimTestsUtil
         }
 
         Vector3 regionExtent = new Vector3(Constants.RegionSize, Constants.RegionSize, Constants.RegionHeight);
-       
+
         RegionInfo info = new RegionInfo();
         info.RegionName = "BSTestRegion";
         info.RegionSizeX = info.RegionSizeY = info.RegionSizeZ = Constants.RegionSize;
         OpenSim.Region.Framework.Scenes.Scene scene = new OpenSim.Region.Framework.Scenes.Scene(info);
 
-        IMesher mesher = new OpenSim.Region.PhysicsModules.Meshing.Meshmerizer();
+        IMesher mesher = new OpenSim.Region.PhysicsModule.Meshing.Meshmerizer();
         INonSharedRegionModule mod = mesher as INonSharedRegionModule;
         mod.Initialise(openSimINI);
         mod.AddRegion(scene);
diff --git a/OpenSim/Region/PhysicsModules/BulletS/Tests/HullCreation.cs b/OpenSim/Region/PhysicsModules/BulletS/Tests/HullCreation.cs
index c0cf19a..c2be568 100644
--- a/OpenSim/Region/PhysicsModules/BulletS/Tests/HullCreation.cs
+++ b/OpenSim/Region/PhysicsModules/BulletS/Tests/HullCreation.cs
@@ -146,7 +146,7 @@ public class HullCreation : OpenSimTestCase
         uint torusLocalID = 125;
         PhysicsScene.AddPrimShape("testTorus", pbs, pos, size, rot, isPhys, torusLocalID);
         BSPrim primTypeTorus = (BSPrim)PhysicsScene.PhysObjects[torusLocalID];
-        
+
         // The actual prim shape creation happens at taint time
         PhysicsScene.ProcessTaints();
 
diff --git a/OpenSim/Region/PhysicsModules/BulletS/Tests/Raycast.cs b/OpenSim/Region/PhysicsModules/BulletS/Tests/Raycast.cs
new file mode 100755
index 0000000..bfa95c1
--- /dev/null
+++ b/OpenSim/Region/PhysicsModules/BulletS/Tests/Raycast.cs
@@ -0,0 +1,124 @@
+/*
+ * 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 copyright
+ *       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 NUnit.Framework;
+using log4net;
+
+using OpenSim.Framework;
+using OpenSim.Region.PhysicsModule.BulletS;
+using OpenSim.Region.PhysicsModules.SharedBase;
+using OpenSim.Tests.Common;
+
+using OpenMetaverse;
+
+namespace OpenSim.Region.PhysicsModule.BulletS.Tests
+{
+    [TestFixture]
+    public class BulletSimRaycast : OpenSimTestCase
+    {
+        // Documentation on attributes: http://www.nunit.org/index.php?p=attributes&r=2.6.1
+        // Documentation on assertions: http://www.nunit.org/index.php?p=assertions&r=2.6.1
+
+        BSScene _physicsScene { get; set; }
+        BSPrim _targetSphere { get; set; }
+        Vector3 _targetSpherePosition { get; set; }
+        float _simulationTimeStep = 0.089f;
+
+        uint _targetLocalID = 123;
+
+        [TestFixtureSetUp]
+        public void Init()
+        {
+            Dictionary<string, string> engineParams = new Dictionary<string, string>();
+            engineParams.Add("UseBulletRaycast", "true");
+            _physicsScene = BulletSimTestsUtil.CreateBasicPhysicsEngine(engineParams);
+
+            PrimitiveBaseShape pbs = PrimitiveBaseShape.CreateSphere();
+            Vector3 pos = new Vector3(100.0f, 100.0f, 50f);
+            _targetSpherePosition = pos;
+            Vector3 size = new Vector3(10f, 10f, 10f);
+            pbs.Scale = size;
+            Quaternion rot = Quaternion.Identity;
+            bool isPhys = false;
+
+            _physicsScene.AddPrimShape("TargetSphere", pbs, pos, size, rot, isPhys, _targetLocalID);
+            _targetSphere = (BSPrim)_physicsScene.PhysObjects[_targetLocalID];
+            // The actual prim shape creation happens at taint time
+            _physicsScene.ProcessTaints();
+
+        }
+
+        [TestFixtureTearDown]
+        public void TearDown()
+        {
+            if (_physicsScene != null)
+            {
+                // The Dispose() will also free any physical objects in the scene
+                _physicsScene.Dispose();
+                _physicsScene = null;
+            }
+        }
+
+        // There is a 10x10x10 sphere at <100,100,50>
+        // Shoot rays around the sphere and verify it hits and doesn't hit
+        // TestCase parameters are <x,y,z> of start and <x,y,z> of end and expected result
+        [TestCase(100f, 50f, 50f, 100f, 150f, 50f, true, "Pass through sphere from front")]
+        [TestCase(50f, 100f, 50f, 150f, 100f, 50f, true, "Pass through sphere from side")]
+        [TestCase(50f, 50f, 50f, 150f, 150f, 50f, true, "Pass through sphere diaginally")]
+        [TestCase(100f, 100f, 100f, 100f, 100f, 20f, true, "Pass through sphere from above")]
+        [TestCase(20f, 20f, 50f, 80f, 80f, 50f, false, "Not reach sphere")]
+        [TestCase(50f, 50f, 65f, 150f, 150f, 65f, false, "Passed over sphere")]
+        public void RaycastAroundObject(float fromX, float fromY, float fromZ, float toX, float toY, float toZ, bool expected, string msg) {
+            Vector3 fromPos = new Vector3(fromX, fromY, fromZ);
+            Vector3 toPos = new Vector3(toX, toY, toZ);
+            Vector3 direction = toPos - fromPos;
+            float len = Vector3.Distance(fromPos, toPos);
+
+            List<ContactResult> results = _physicsScene.RaycastWorld(fromPos, direction, len, 1);
+
+            if (expected) {
+                // The  test coordinates should generate a hit
+                Assert.True(results.Count != 0, msg + ": Did not return a hit but expected to.");
+                Assert.True(results.Count == 1, msg + ": Raycast returned not just one hit result.");
+                Assert.True(results[0].ConsumerID == _targetLocalID, msg + ": Raycast returned a collision object other than the target");
+            }
+            else
+            {
+                // The test coordinates should not generate a hit
+                if (results.Count > 0)
+                {
+                    Assert.False(results.Count > 0, msg + ": Returned a hit at " + results[0].Pos.ToString());
+                }
+            }
+        }
+    }
+}
\ No newline at end of file