46 files changed, 1619 insertions, 388 deletions
diff --git a/OpenSim/Region/Physics/BasicPhysicsPlugin/AssemblyInfo.cs b/OpenSim/Region/Physics/BasicPhysicsPlugin/AssemblyInfo.cs
index ffcb01e..7d054dd 100644
--- a/OpenSim/Region/Physics/BasicPhysicsPlugin/AssemblyInfo.cs
+++ b/OpenSim/Region/Physics/BasicPhysicsPlugin/AssemblyInfo.cs
@@ -55,4 +55,4 @@ using System.Runtime.InteropServices;
 // You can specify all values by your own or you can build default build and revision
 // numbers with the '*' character (the default):
-[assembly : AssemblyVersion("0.8.0.*")]
+[assembly : AssemblyVersion("0.8.2.*")]
diff --git a/OpenSim/Region/Physics/BasicPhysicsPlugin/BasicPhysicsActor.cs b/OpenSim/Region/Physics/BasicPhysicsPlugin/BasicPhysicsActor.cs
index 0d17e0e..43fba7b 100644
--- a/OpenSim/Region/Physics/BasicPhysicsPlugin/BasicPhysicsActor.cs
+++ b/OpenSim/Region/Physics/BasicPhysicsPlugin/BasicPhysicsActor.cs
@@ -36,8 +36,6 @@ namespace OpenSim.Region.Physics.BasicPhysicsPlugin
 {
    public class BasicActor : PhysicsActor
    {
-        private Vector3 _size;
        public BasicActor(Vector3 size)
        {
            Size = size;
@@ -240,6 +238,7 @@ namespace OpenSim.Region.Physics.BasicPhysicsPlugin
        public override bool PIDActive
        {
+            get { return false; }
            set { return; }
        }
diff --git a/OpenSim/Region/Physics/BasicPhysicsPlugin/BasicPhysicsPrim.cs b/OpenSim/Region/Physics/BasicPhysicsPlugin/BasicPhysicsPrim.cs
index 47d7df3..dfe4c19 100644
--- a/OpenSim/Region/Physics/BasicPhysicsPlugin/BasicPhysicsPrim.cs
+++ b/OpenSim/Region/Physics/BasicPhysicsPlugin/BasicPhysicsPrim.cs
@@ -251,6 +251,7 @@ namespace OpenSim.Region.Physics.BasicPhysicsPlugin
        public override bool PIDActive
        {
+            get { return false; }
            set { return; }
        }
diff --git a/OpenSim/Region/Physics/BasicPhysicsPlugin/BasicPhysicsScene.cs b/OpenSim/Region/Physics/BasicPhysicsPlugin/BasicPhysicsScene.cs
index 8e40561..06a205e 100644
--- a/OpenSim/Region/Physics/BasicPhysicsPlugin/BasicPhysicsScene.cs
+++ b/OpenSim/Region/Physics/BasicPhysicsPlugin/BasicPhysicsScene.cs
@@ -80,10 +80,11 @@ namespace OpenSim.Region.Physics.BasicPhysicsPlugin
            return prim;
        }
-        public override PhysicsActor AddAvatar(string avName, Vector3 position, Vector3 size, bool isFlying)
+        public override PhysicsActor AddAvatar(string avName, Vector3 position, Vector3 velocity, Vector3 size, bool isFlying)
        {
            BasicActor act = new BasicActor(size);
            act.Position = position;
+            act.Velocity = velocity;
            act.Flying = isFlying;
            _actors.Add(act);
            return act;
@@ -147,6 +148,7 @@ namespace OpenSim.Region.Physics.BasicPhysicsPlugin
                    terrainHeight = _heightMap[(int)actor.Position.Y * (int)m_regionExtent.Y + (int)actor.Position.X];
                float height = terrainHeight + actor.Size.Z;
+//                Console.WriteLine("height {0}, actorPosition {1}", height, actorPosition);
                if (actor.Flying)
                {
diff --git a/OpenSim/Region/Physics/BulletSPlugin/BSAPIXNA.cs b/OpenSim/Region/Physics/BulletSPlugin/BSAPIXNA.cs
index 17ebed2..741f8db 100755
--- a/OpenSim/Region/Physics/BulletSPlugin/BSAPIXNA.cs
+++ b/OpenSim/Region/Physics/BulletSPlugin/BSAPIXNA.cs
@@ -658,7 +658,7 @@ private sealed class BulletConstraintXNA : BulletConstraint
        IndexedVector3 frame2v = new IndexedVector3(pframe2.X, pframe2.Y, pframe2.Z);
        IndexedQuaternion frame2rot = new IndexedQuaternion(pframe2rot.X, pframe2rot.Y, pframe2rot.Z, pframe2rot.W);
        IndexedMatrix frame2 = IndexedMatrix.CreateFromQuaternion(frame2rot);
-        frame2._origin = frame1v;
+        frame2._origin = frame2v;
        constraint.SetFrames(ref frame1, ref frame2);
        return true;
    }
@@ -1311,7 +1311,7 @@ private sealed class BulletConstraintXNA : BulletConstraint
        /* TODO */
        ConfigurationParameters[] configparms = new ConfigurationParameters[1];
        configparms[0] = parms;
-        Vector3 worldExtent = new Vector3(Constants.RegionSize, Constants.RegionSize, Constants.RegionHeight);
+        Vector3 worldExtent = maxPosition;
        m_maxCollisions = maxCollisions;
        m_maxUpdatesPerFrame = maxUpdates;
        specialCollisionObjects = new Dictionary<uint, GhostObject>();
@@ -2255,7 +2255,6 @@ private sealed class BulletConstraintXNA : BulletConstraint
            world.LastCollisionDesc = 0;
            world.LastEntityProperty = 0;
            numSimSteps = world.StepSimulation(timeStep, m_maxSubSteps, m_fixedTimeStep);
-            int updates = 0;
            PersistentManifold contactManifold;
            CollisionObject objA;
diff --git a/OpenSim/Region/Physics/BulletSPlugin/BSActorAvatarMove.cs b/OpenSim/Region/Physics/BulletSPlugin/BSActorAvatarMove.cs
index 1bcf879..bde4557 100755
--- a/OpenSim/Region/Physics/BulletSPlugin/BSActorAvatarMove.cs
+++ b/OpenSim/Region/Physics/BulletSPlugin/BSActorAvatarMove.cs
@@ -1,4 +1,4 @@
-/*
+/*
 * Copyright (c) Contributors, http://opensimulator.org/
 * See CONTRIBUTORS.TXT for a full list of copyright holders.
 *
@@ -30,6 +30,7 @@ using System.Collections.Generic;
 using System.Linq;
 using System.Text;
+using OpenSim.Framework;
 using OpenSim.Region.Physics.Manager;
 using OMV = OpenMetaverse;
@@ -70,8 +71,7 @@ public class BSActorAvatarMove : BSActor
    public override void Dispose()
    {
        base.SetEnabled(false);
-        // Now that turned off, remove any state we have in the scene.
+        DeactivateAvatarMove();
-        Refresh();
    }
    // Called when physical parameters (properties set in Bullet) need to be re-applied.
@@ -109,6 +109,10 @@ 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);
@@ -205,6 +209,17 @@ public class BSActorAvatarMove : BSActor
                    // Flying and not colliding and velocity nearly zero.
                    m_controllingPrim.ZeroMotion(true /* inTaintTime */);
                }
+                else
+                {
+                    //We are falling but are not touching any keys make sure not falling too fast
+                    if (m_controllingPrim.RawVelocity.Z < BSParam.AvatarTerminalVelocity)
+                    {
+                        OMV.Vector3 slowingForce = new OMV.Vector3(0f, 0f, BSParam.AvatarTerminalVelocity - m_controllingPrim.RawVelocity.Z) * m_controllingPrim.Mass;
+                        m_physicsScene.PE.ApplyCentralImpulse(m_controllingPrim.PhysBody, slowingForce);
+                    }
+                }
            }
            m_physicsScene.DetailLog("{0},BSCharacter.MoveMotor,taint,stopping,target={1},colliding={2}",
@@ -227,7 +242,6 @@ public class BSActorAvatarMove : BSActor
                stepVelocity.Z = m_controllingPrim.RawVelocity.Z;
            }
            // Colliding and not flying with an upward force. The avatar must be trying to jump.
            if (!m_controllingPrim.Flying && m_controllingPrim.IsColliding && stepVelocity.Z > 0)
            {
@@ -253,12 +267,34 @@ public class BSActorAvatarMove : BSActor
                }
                else
                {
-                    // Since we're not affected by anything, whatever vertical motion the avatar has, continue that.
+                    
-                    stepVelocity.Z = m_controllingPrim.RawVelocity.Z;
+                    // 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);
            }
+            //Alicia: Maintain minimum height when flying.
+            // SL has a flying effect that keeps the avatar flying above the ground by some margin
+            if (m_controllingPrim.Flying)
+            {
+                float hover_height = m_physicsScene.TerrainManager.GetTerrainHeightAtXYZ(m_controllingPrim.RawPosition)
+                                                        + BSParam.AvatarFlyingGroundMargin;
+                if( m_controllingPrim.Position.Z < hover_height)
+                {
+                    stepVelocity.Z += BSParam.AvatarFlyingGroundUpForce;
+                }
+            }
            // 'stepVelocity' is now the speed we'd like the avatar to move in. Turn that into an instantanous force.
            OMV.Vector3 moveForce = (stepVelocity - m_controllingPrim.RawVelocity) * m_controllingPrim.Mass;
@@ -304,7 +340,7 @@ public class BSActorAvatarMove : BSActor
            // float nearFeetHeightMin = m_controllingPrim.RawPosition.Z - (m_controllingPrim.Size.Z / 2f) + 0.05f;
            // Note: there is a problem with the computation of the capsule height. Thus RawPosition is off
            //    from the height. Revisit size and this computation when height is scaled properly.
-            float nearFeetHeightMin = m_controllingPrim.RawPosition.Z - (m_controllingPrim.Size.Z / 2f) - 0.05f;
+            float nearFeetHeightMin = m_controllingPrim.RawPosition.Z - (m_controllingPrim.Size.Z / 2f) - BSParam.AvatarStepGroundFudge;
            float nearFeetHeightMax = nearFeetHeightMin + BSParam.AvatarStepHeight;
            // Look for a collision point that is near the character's feet and is oriented the same as the charactor is.
@@ -326,15 +362,25 @@ public class BSActorAvatarMove : BSActor
                            if (touchPosition.Z >= nearFeetHeightMin && touchPosition.Z <= nearFeetHeightMax)
                            {
                                // This contact is within the 'near the feet' range.
-                                // The normal should be our contact point to the object so it is pointing away
+                                // The step is presumed to be more or less vertical. Thus the Z component should
-                                //    thus the difference between our facing orientation and the normal should be small.
+                                //    be nearly horizontal.
                                OMV.Vector3 directionFacing = OMV.Vector3.UnitX * m_controllingPrim.RawOrientation;
                                OMV.Vector3 touchNormal = OMV.Vector3.Normalize(kvp.Value.SurfaceNormal);
-                                float diff = Math.Abs(OMV.Vector3.Distance(directionFacing, touchNormal));
+                                const float PIOver2 = 1.571f; // Used to make unit vector axis into approx radian angles
-                                if (diff < BSParam.AvatarStepApproachFactor)
+                                // m_physicsScene.DetailLog("{0},BSCharacter.WalkUpStairs,avNormal={1},colNormal={2},diff={3}",
+                                //             m_controllingPrim.LocalID, directionFacing, touchNormal,
+                                //             Math.Abs(OMV.Vector3.Distance(directionFacing, touchNormal)) );
+                                if ((Math.Abs(directionFacing.Z) * PIOver2) < BSParam.AvatarStepAngle
+                                    && (Math.Abs(touchNormal.Z) * PIOver2) < BSParam.AvatarStepAngle)
                                {
-                                    if (highestTouchPosition.Z < touchPosition.Z)
+                                    // The normal should be our contact point to the object so it is pointing away
-                                        highestTouchPosition = touchPosition;
+                                    //    thus the difference between our facing orientation and the normal should be small.
+                                    float diff = Math.Abs(OMV.Vector3.Distance(directionFacing, touchNormal));
+                                    if (diff < BSParam.AvatarStepApproachFactor)
+                                    {
+                                        if (highestTouchPosition.Z < touchPosition.Z)
+                                            highestTouchPosition = touchPosition;
+                                    }
                                }
                            }
                        }
@@ -399,8 +445,8 @@ public class BSActorAvatarMove : BSActor
                    m_controllingPrim.ForcePosition = m_controllingPrim.RawPosition + displacement;
                }
            }
-            m_physicsScene.DetailLog("{0},BSCharacter.WalkUpStairs.ComputeStairCorrection,disp={1},force={2}",
+            m_physicsScene.DetailLog("{0},BSCharacter.WalkUpStairs.ComputeStairCorrection,stepUp={1},isp={2},force={3}",
-                                        m_controllingPrim.LocalID, displacement, ret);
+                                        m_controllingPrim.LocalID, stepUp, displacement, ret);
        }
        return ret;
diff --git a/OpenSim/Region/Physics/BulletSPlugin/BSActorHover.cs b/OpenSim/Region/Physics/BulletSPlugin/BSActorHover.cs
index 8a79809..e54c27b 100755
--- a/OpenSim/Region/Physics/BulletSPlugin/BSActorHover.cs
+++ b/OpenSim/Region/Physics/BulletSPlugin/BSActorHover.cs
@@ -58,6 +58,7 @@ public class BSActorHover : BSActor
    public override void Dispose()
    {
        Enabled = false;
+        DeactivateHover();
    }
    // Called when physical parameters (properties set in Bullet) need to be re-applied.
diff --git a/OpenSim/Region/Physics/BulletSPlugin/BSActorLockAxis.cs b/OpenSim/Region/Physics/BulletSPlugin/BSActorLockAxis.cs
index 8b0fdeb..3b3c161 100755
--- a/OpenSim/Region/Physics/BulletSPlugin/BSActorLockAxis.cs
+++ b/OpenSim/Region/Physics/BulletSPlugin/BSActorLockAxis.cs
@@ -1,4 +1,4 @@
-/*
+/*
 * Copyright (c) Contributors, http://opensimulator.org/
 * See CONTRIBUTORS.TXT for a full list of copyright holders.
 *
@@ -36,13 +36,20 @@ namespace OpenSim.Region.Physics.BulletSPlugin
 {
 public class BSActorLockAxis : BSActor
 {
-    BSConstraint LockAxisConstraint = null;
+    private BSConstraint LockAxisConstraint = null;
+    private bool HaveRegisteredForBeforeStepCallback = false;
+    // The lock access flags (which axises were locked) when the contraint was built.
+    // Used to see if locking has changed since when the constraint was built.
+    OMV.Vector3 LockAxisLinearFlags;
+    OMV.Vector3 LockAxisAngularFlags;
    public BSActorLockAxis(BSScene physicsScene, BSPhysObject pObj, string actorName)
        : base(physicsScene, pObj, actorName)
    {
        m_physicsScene.DetailLog("{0},BSActorLockAxis,constructor", m_controllingPrim.LocalID);
        LockAxisConstraint = null;
+        HaveRegisteredForBeforeStepCallback = false;
    }
    // BSActor.isActive
@@ -55,6 +62,8 @@ public class BSActorLockAxis : BSActor
    // BSActor.Dispose()
    public override void Dispose()
    {
+        Enabled = false;
+        UnRegisterForBeforeStepCallback();
        RemoveAxisLockConstraint();
    }
@@ -63,22 +72,28 @@ public class BSActorLockAxis : BSActor
    // BSActor.Refresh()
    public override void Refresh()
    {
-        m_physicsScene.DetailLog("{0},BSActorLockAxis,refresh,lockedAxis={1},enabled={2},pActive={3}",
+        // Since the axis logging is done with a constraint, Refresh() time is good for
-                                    m_controllingPrim.LocalID, m_controllingPrim.LockedAngularAxis, Enabled, m_controllingPrim.IsPhysicallyActive);
+        //    changing parameters but this needs to wait until the prim/linkset is physically
+        //    constructed. Therefore, the constraint itself is placed at pre-step time.
        // If all the axis are free, we don't need to exist
-        if (m_controllingPrim.LockedAngularAxis == m_controllingPrim.LockedAxisFree)
+        // Refresh() only turns off. Enabling is done by InitializeAxisActor()
+        //      whenever parameters are changed.
+        //      This leaves 'enable' free to turn off an actor when it is not wanted to run.
+        if (m_controllingPrim.LockedAngularAxis == m_controllingPrim.LockedAxisFree
+                && m_controllingPrim.LockedLinearAxis == m_controllingPrim.LockedAxisFree)
        {
            Enabled = false;
        }
-        // If the object is physically active, add the axis locking constraint
        if (isActive)
        {
-            AddAxisLockConstraint();
+            RegisterForBeforeStepCallback();
        }
        else
        {
-            RemoveAxisLockConstraint();
+            RemoveDependencies();
+            UnRegisterForBeforeStepCallback();
        }
    }
@@ -88,18 +103,56 @@ public class BSActorLockAxis : BSActor
    // BSActor.RemoveDependencies()
    public override void RemoveDependencies()
    {
-        if (LockAxisConstraint != null)
+        RemoveAxisLockConstraint();
+    }
+    private void RegisterForBeforeStepCallback()
+    {
+        if (!HaveRegisteredForBeforeStepCallback)
        {
-            // If a constraint is set up, remove it from the physical scene
+            m_physicsScene.BeforeStep += PhysicsScene_BeforeStep;
-            RemoveAxisLockConstraint();
+            HaveRegisteredForBeforeStepCallback = true;
-            // Schedule a call before the next simulation step to restore the constraint.
+        }
-            m_physicsScene.PostTaintObject("BSActorLockAxis:" + ActorName, m_controllingPrim.LocalID, delegate()
+    }
+    private void UnRegisterForBeforeStepCallback()
+    {
+        if (HaveRegisteredForBeforeStepCallback)
+        {
+            m_physicsScene.BeforeStep -= PhysicsScene_BeforeStep;
+            HaveRegisteredForBeforeStepCallback = false;
+        }
+    }
+    private void PhysicsScene_BeforeStep(float timestep)
+    {
+        // If all the axis are free, we don't need to exist
+        if (m_controllingPrim.LockedAngularAxis == m_controllingPrim.LockedAxisFree
+                && m_controllingPrim.LockedLinearAxis == m_controllingPrim.LockedAxisFree)
+        {
+            Enabled = false;
+        }
+        // If the object is physically active, add the axis locking constraint
+        if (isActive)
+        {
+            // Check to see if the locking parameters have changed
+            if (m_controllingPrim.LockedLinearAxis != this.LockAxisLinearFlags
+                || m_controllingPrim.LockedAngularAxis != this.LockAxisAngularFlags)
            {
-                Refresh();
+                // The locking has changed. Remove the old constraint and build a new one
-            });
+                RemoveAxisLockConstraint();
+            }
+            AddAxisLockConstraint();
+        }
+        else
+        {
+            RemoveAxisLockConstraint();
        }
    }
+    // Note that this relies on being called at TaintTime
    private void AddAxisLockConstraint()
    {
        if (LockAxisConstraint == null)
@@ -118,64 +171,43 @@ public class BSActorLockAxis : BSActor
            LockAxisConstraint = axisConstrainer;
            m_physicsScene.Constraints.AddConstraint(LockAxisConstraint);
+            // Remember the clocking being inforced so we can notice if they have changed
+            LockAxisLinearFlags = m_controllingPrim.LockedLinearAxis;
+            LockAxisAngularFlags = m_controllingPrim.LockedAngularAxis;
            // The constraint is tied to the world and oriented to the prim.
-            // Free to move linearly in the region
+            if (!axisConstrainer.SetLinearLimits(m_controllingPrim.LockedLinearAxisLow, m_controllingPrim.LockedLinearAxisHigh))
-            OMV.Vector3 linearLow = OMV.Vector3.Zero;
-            OMV.Vector3 linearHigh = m_physicsScene.TerrainManager.DefaultRegionSize;
-            if (m_controllingPrim.LockedLinearAxis.X != BSPhysObject.FreeAxis)
            {
-                linearLow.X = m_controllingPrim.RawPosition.X;
+                m_physicsScene.DetailLog("{0},BSActorLockAxis.AddAxisLockConstraint,failedSetLinearLimits",
-                linearHigh.X = m_controllingPrim.RawPosition.X;
+                        m_controllingPrim.LocalID);
            }
-            if (m_controllingPrim.LockedLinearAxis.Y != BSPhysObject.FreeAxis)
-            {
-                linearLow.Y = m_controllingPrim.RawPosition.Y;
-                linearHigh.Y = m_controllingPrim.RawPosition.Y;
-            }
-            if (m_controllingPrim.LockedLinearAxis.Z != BSPhysObject.FreeAxis)
-            {
-                linearLow.Z = m_controllingPrim.RawPosition.Z;
-                linearHigh.Z = m_controllingPrim.RawPosition.Z;
-            }
-            axisConstrainer.SetLinearLimits(linearLow, linearHigh);
-            // Angular with some axis locked
+            if (!axisConstrainer.SetAngularLimits(m_controllingPrim.LockedAngularAxisLow, m_controllingPrim.LockedAngularAxisHigh))
-            float fPI = (float)Math.PI;
-            OMV.Vector3 angularLow = new OMV.Vector3(-fPI, -fPI, -fPI);
-            OMV.Vector3 angularHigh = new OMV.Vector3(fPI, fPI, fPI);
-            if (m_controllingPrim.LockedAngularAxis.X != BSPhysObject.FreeAxis)
-            {
-                angularLow.X = 0f;
-                angularHigh.X = 0f;
-            }
-            if (m_controllingPrim.LockedAngularAxis.Y != BSPhysObject.FreeAxis)
            {
-                angularLow.Y = 0f;
+                m_physicsScene.DetailLog("{0},BSActorLockAxis.AddAxisLockConstraint,failedSetAngularLimits",
-                angularHigh.Y = 0f;
+                        m_controllingPrim.LocalID);
-            }
-            if (m_controllingPrim.LockedAngularAxis.Z != BSPhysObject.FreeAxis)
-            {
-                angularLow.Z = 0f;
-                angularHigh.Z = 0f;
-            }
-            if (!axisConstrainer.SetAngularLimits(angularLow, angularHigh))
-            {
-                m_physicsScene.DetailLog("{0},BSActorLockAxis.AddAxisLockConstraint,failedSetAngularLimits", m_controllingPrim.LocalID);
            }
            m_physicsScene.DetailLog("{0},BSActorLockAxis.AddAxisLockConstraint,create,linLow={1},linHi={2},angLow={3},angHi={4}",
-                                        m_controllingPrim.LocalID, linearLow, linearHigh, angularLow, angularHigh);
+                                        m_controllingPrim.LocalID,
+                                        m_controllingPrim.LockedLinearAxisLow,
+                                        m_controllingPrim.LockedLinearAxisHigh,
+                                        m_controllingPrim.LockedAngularAxisLow,
+                                        m_controllingPrim.LockedAngularAxisHigh);
            // Constants from one of the posts mentioned above and used in Bullet's ConstraintDemo.
            axisConstrainer.TranslationalLimitMotor(true /* enable */, 5.0f, 0.1f);
            axisConstrainer.RecomputeConstraintVariables(m_controllingPrim.RawMass);
+            RegisterForBeforeStepCallback();
        }
    }
    private void RemoveAxisLockConstraint()
    {
+        UnRegisterForBeforeStepCallback();
        if (LockAxisConstraint != null)
        {
            m_physicsScene.Constraints.RemoveAndDestroyConstraint(LockAxisConstraint);
diff --git a/OpenSim/Region/Physics/BulletSPlugin/BSActorMoveToTarget.cs b/OpenSim/Region/Physics/BulletSPlugin/BSActorMoveToTarget.cs
index bdf4bc0..1145006 100755
--- a/OpenSim/Region/Physics/BulletSPlugin/BSActorMoveToTarget.cs
+++ b/OpenSim/Region/Physics/BulletSPlugin/BSActorMoveToTarget.cs
@@ -59,6 +59,7 @@ public class BSActorMoveToTarget : BSActor
    public override void Dispose()
    {
        Enabled = false;
+        DeactivateMoveToTarget();
    }
    // Called when physical parameters (properties set in Bullet) need to be re-applied.
diff --git a/OpenSim/Region/Physics/BulletSPlugin/BSActorSetForce.cs b/OpenSim/Region/Physics/BulletSPlugin/BSActorSetForce.cs
index 96fa0b6..4e81363 100755
--- a/OpenSim/Region/Physics/BulletSPlugin/BSActorSetForce.cs
+++ b/OpenSim/Region/Physics/BulletSPlugin/BSActorSetForce.cs
@@ -58,6 +58,7 @@ public class BSActorSetForce : BSActor
    public override void Dispose()
    {
        Enabled = false;
+        DeactivateSetForce();
    }
    // Called when physical parameters (properties set in Bullet) need to be re-applied.
diff --git a/OpenSim/Region/Physics/BulletSPlugin/BSActorSetTorque.cs b/OpenSim/Region/Physics/BulletSPlugin/BSActorSetTorque.cs
index 65098e1..79e1d38 100755
--- a/OpenSim/Region/Physics/BulletSPlugin/BSActorSetTorque.cs
+++ b/OpenSim/Region/Physics/BulletSPlugin/BSActorSetTorque.cs
@@ -58,6 +58,7 @@ public class BSActorSetTorque : BSActor
    public override void Dispose()
    {
        Enabled = false;
+        DeactivateSetTorque();
    }
    // Called when physical parameters (properties set in Bullet) need to be re-applied.
diff --git a/OpenSim/Region/Physics/BulletSPlugin/BSActors.cs b/OpenSim/Region/Physics/BulletSPlugin/BSActors.cs
index e0ccc50..7f45e2c 100755
--- a/OpenSim/Region/Physics/BulletSPlugin/BSActors.cs
+++ b/OpenSim/Region/Physics/BulletSPlugin/BSActors.cs
@@ -32,12 +32,10 @@ namespace OpenSim.Region.Physics.BulletSPlugin
 {
 public class BSActorCollection
 {
-    private BSScene m_physicsScene { get; set; }
    private Dictionary<string, BSActor> m_actors;
-    public BSActorCollection(BSScene physicsScene)
+    public BSActorCollection()
    {
-        m_physicsScene = physicsScene;
        m_actors = new Dictionary<string, BSActor>();
    }
    public void Add(string name, BSActor actor)
diff --git a/OpenSim/Region/Physics/BulletSPlugin/BSApiTemplate.cs b/OpenSim/Region/Physics/BulletSPlugin/BSApiTemplate.cs
index be6f152..8491c0f 100644
--- a/OpenSim/Region/Physics/BulletSPlugin/BSApiTemplate.cs
+++ b/OpenSim/Region/Physics/BulletSPlugin/BSApiTemplate.cs
@@ -43,9 +43,11 @@ public enum ConstraintType : int
        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
    //
-    FIXED_CONSTRAINT_TYPE = 1234    // BulletSim constraint that is fixed and unmoving
+    BS_FIXED_CONSTRAINT_TYPE = 1234    // BulletSim constraint that is fixed and unmoving
 }
 // ===============================================================================
@@ -209,6 +211,21 @@ public struct HACDParams
        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
 }
 // The states a bullet collision object can have
diff --git a/OpenSim/Region/Physics/BulletSPlugin/BSCharacter.cs b/OpenSim/Region/Physics/BulletSPlugin/BSCharacter.cs
index fc18960..9c3f160 100644
--- a/OpenSim/Region/Physics/BulletSPlugin/BSCharacter.cs
+++ b/OpenSim/Region/Physics/BulletSPlugin/BSCharacter.cs
@@ -61,18 +61,31 @@ public sealed class BSCharacter : BSPhysObject
    private const string AvatarMoveActorName = "BSCharacter.AvatarMove";
    private OMV.Vector3 _PIDTarget;
-    private bool _usePID;
    private float _PIDTau;
-    public BSCharacter(uint localID, String avName, BSScene parent_scene, OMV.Vector3 pos, OMV.Vector3 size, bool isFlying)
+//        public override OMV.Vector3 RawVelocity 
+//        { get { return base.RawVelocity; } 
+//            set { 
+//                if (value != base.RawVelocity)
+//                    Util.PrintCallStack();
+//                Console.WriteLine("Set rawvel to {0}", value);
+//                base.RawVelocity = value; }
+//        }
+    // Avatars are always complete (in the physics engine sense)
+    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)
            : base(parent_scene, localID, avName, "BSCharacter")
    {
        _physicsActorType = (int)ActorTypes.Agent;
-        RawPosition = pos;
+        RawPosition = pos;        
        _flying = isFlying;
        RawOrientation = OMV.Quaternion.Identity;
-        RawVelocity = OMV.Vector3.Zero;
+        RawVelocity = vel;
        _buoyancy = ComputeBuoyancyFromFlying(isFlying);
        Friction = BSParam.AvatarStandingFriction;
        Density = BSParam.AvatarDensity;
@@ -89,13 +102,15 @@ public sealed class BSCharacter : BSPhysObject
        // set _avatarVolume and _mass based on capsule size, _density and Scale
        ComputeAvatarVolumeAndMass();
-        DetailLog("{0},BSCharacter.create,call,size={1},scale={2},density={3},volume={4},mass={5},pos={6}",
+        DetailLog(
-                            LocalID, _size, Scale, Density, _avatarVolume, RawMass, pos);
+            "{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);
        // do actual creation in taint time
        PhysScene.TaintedObject(LocalID, "BSCharacter.create", delegate()
        {
            DetailLog("{0},BSCharacter.create,taint", LocalID);
            // New body and shape into PhysBody and PhysShape
            PhysScene.Shapes.GetBodyAndShape(true, PhysScene.World, this);
@@ -134,7 +149,6 @@ public sealed class BSCharacter : BSPhysObject
    {
        PhysScene.PE.RemoveObjectFromWorld(PhysScene.World, PhysBody);
-        ZeroMotion(true);
        ForcePosition = RawPosition;
        // Set the velocity
@@ -142,6 +156,7 @@ public sealed class BSCharacter : BSPhysObject
            m_moveActor.SetVelocityAndTarget(RawVelocity, RawVelocity, false);
        ForceVelocity = RawVelocity;
+        TargetVelocity = RawVelocity;
        // This will enable or disable the flying buoyancy of the avatar.
        // Needs to be reset especially when an avatar is recreated after crossing a region boundry.
@@ -174,15 +189,19 @@ public sealed class BSCharacter : BSPhysObject
        PhysScene.PE.UpdateSingleAabb(PhysScene.World, PhysBody);
        // Do this after the object has been added to the world
-        PhysBody.collisionType = CollisionType.Avatar;
+        if (BSParam.AvatarToAvatarCollisionsByDefault)
+            PhysBody.collisionType = CollisionType.Avatar;
+        else
+            PhysBody.collisionType = CollisionType.PhantomToOthersAvatar;
        PhysBody.ApplyCollisionMask(PhysScene);
    }
    public override void RequestPhysicsterseUpdate()
    {
        base.RequestPhysicsterseUpdate();
    }
    // No one calls this method so I don't know what it could possibly mean
    public override bool Stopped { get { return false; } }
@@ -263,6 +282,7 @@ public sealed class BSCharacter : BSPhysObject
                PhysScene.PE.ClearAllForces(PhysBody);
        });
    }
    public override void ZeroAngularMotion(bool inTaintTime)
    {
        _rotationalVelocity = OMV.Vector3.Zero;
@@ -426,7 +446,7 @@ public sealed class BSCharacter : BSPhysObject
            m_targetVelocity = value;
            OMV.Vector3 targetVel = value;
            if (_setAlwaysRun && !_flying)
-                targetVel *= new OMV.Vector3(BSParam.AvatarAlwaysRunFactor, BSParam.AvatarAlwaysRunFactor, 0f);
+                targetVel *= new OMV.Vector3(BSParam.AvatarAlwaysRunFactor, BSParam.AvatarAlwaysRunFactor, 1f);
            if (m_moveActor != null)
                m_moveActor.SetVelocityAndTarget(RawVelocity, targetVel, false /* inTaintTime */);
@@ -437,32 +457,40 @@ public sealed class BSCharacter : BSPhysObject
        get { return RawVelocity; }
        set {
            RawVelocity = value;
-            // m_log.DebugFormat("{0}: set velocity = {1}", LogHeader, RawVelocity);
+                OMV.Vector3 vel = RawVelocity;
+            DetailLog("{0}: set Velocity = {1}", LocalID, value);
            PhysScene.TaintedObject(LocalID, "BSCharacter.setVelocity", delegate()
            {
                if (m_moveActor != null)
-                    m_moveActor.SetVelocityAndTarget(RawVelocity, RawVelocity, true /* inTaintTime */);
+                    m_moveActor.SetVelocityAndTarget(vel, vel, true /* inTaintTime */);
-                DetailLog("{0},BSCharacter.setVelocity,taint,vel={1}", LocalID, RawVelocity);
+                DetailLog("{0},BSCharacter.setVelocity,taint,vel={1}", LocalID, vel);
-                ForceVelocity = RawVelocity;
+                ForceVelocity = vel;
            });
        }
    }
    public override OMV.Vector3 ForceVelocity {
        get { return RawVelocity; }
        set {
            PhysScene.AssertInTaintTime("BSCharacter.ForceVelocity");
+//                Util.PrintCallStack();
+            DetailLog("{0}: set ForceVelocity = {1}", LocalID, value);
            RawVelocity = value;
            PhysScene.PE.SetLinearVelocity(PhysBody, RawVelocity);
            PhysScene.PE.Activate(PhysBody, true);
        }
    }
    public override OMV.Vector3 Torque {
        get { return RawTorque; }
        set { RawTorque = value;
        }
    }
    public override float CollisionScore {
        get { return _collisionScore; }
        set { _collisionScore = value;
@@ -614,9 +642,9 @@ public sealed class BSCharacter : BSPhysObject
    public override OMV.Vector3 PIDTarget {
        set { _PIDTarget = value; }
    }
-    public override bool PIDActive {
-        set { _usePID = value; }
+    public override bool PIDActive { get; set; }
-    }
    public override float PIDTau {
        set { _PIDTau = value; }
    }
@@ -657,7 +685,7 @@ public sealed class BSCharacter : BSPhysObject
    private OMV.Vector3 ComputeAvatarScale(OMV.Vector3 size)
    {
-        OMV.Vector3 newScale;
+        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)
@@ -670,8 +698,6 @@ public sealed class BSCharacter : BSPhysObject
        //     for a asymmetrical capsule, other parts of the code presume it is cylindrical.
        // Scale is multiplier of radius with one of "0.5"
-        newScale.X = size.X / 2f;
-        newScale.Y = size.Y / 2f;
        float heightAdjust = BSParam.AvatarHeightMidFudge;
        if (BSParam.AvatarHeightLowFudge != 0f || BSParam.AvatarHeightHighFudge != 0f)
@@ -692,8 +718,17 @@ public sealed class BSCharacter : BSPhysObject
                heightAdjust += ((midHeightOffset) / (AVATAR_HI - AVATAR_MID)) * BSParam.AvatarHeightHighFudge;
            }
        }
-        // The total scale height is the central cylindar plus the caps on the two ends.
+        if (BSParam.AvatarShape == BSShapeCollection.AvatarShapeCapsule)
-        newScale.Z = (size.Z + (Math.Min(size.X, size.Y) * 2) + heightAdjust) / 2f;
+        {
+            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
+        {
+            newScale.Z = size.Z + heightAdjust;
+        }
        // 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
@@ -737,7 +772,18 @@ public sealed class BSCharacter : BSPhysObject
        //    and will send agent updates to the clients if velocity changes by more than
        //    0.001m/s. Bullet introduces a lot of jitter in the velocity which causes many
        //    extra updates.
-        if (!entprop.Velocity.ApproxEquals(RawVelocity, 0.1f))
+        //
+        // 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
+        // bound and an upper bound, where the difference between the two is enough to trigger a large delta v update
+        // and subsequently trigger an update in ScenePresence.SendTerseUpdateToAllClients().  The cause of this cycle (feedback?)
+        // has not yet been identified.
+        //
+        // If there is a threshold below 0.4 or no threshold check at all (as in ODE), then RawVelocity stays constant and extra
+        // updates are not triggered in ScenePresence.SendTerseUpdateToAllClients().
+//        if (!entprop.Velocity.ApproxEquals(RawVelocity, 0.1f))
            RawVelocity = entprop.Velocity;
        _acceleration = entprop.Acceleration;
diff --git a/OpenSim/Region/Physics/BulletSPlugin/BSDynamics.cs b/OpenSim/Region/Physics/BulletSPlugin/BSDynamics.cs
index 7b98f9d..c6d6331 100644
--- a/OpenSim/Region/Physics/BulletSPlugin/BSDynamics.cs
+++ b/OpenSim/Region/Physics/BulletSPlugin/BSDynamics.cs
@@ -42,7 +42,9 @@ namespace OpenSim.Region.Physics.BulletSPlugin
 {
    public sealed class BSDynamics : BSActor
    {
+#pragma warning disable 414
        private static string LogHeader = "[BULLETSIM VEHICLE]";
+#pragma warning restore 414
        // the prim this dynamic controller belongs to
        private BSPrimLinkable ControllingPrim { get; set; }
@@ -74,8 +76,8 @@ namespace OpenSim.Region.Physics.BulletSPlugin
        private Vector3 m_linearMotorOffset = Vector3.Zero;             // the point of force can be offset from the center
        private Vector3 m_linearMotorDirectionLASTSET = Vector3.Zero;   // velocity requested by LSL
        private Vector3 m_linearFrictionTimescale = Vector3.Zero;
-        private float m_linearMotorDecayTimescale = 0;
+        private float m_linearMotorDecayTimescale = 1;
-        private float m_linearMotorTimescale = 0;
+        private float m_linearMotorTimescale = 1;
        private Vector3 m_lastLinearVelocityVector = Vector3.Zero;
        private Vector3 m_lastPositionVector = Vector3.Zero;
        // private bool m_LinearMotorSetLastFrame = false;
@@ -86,8 +88,8 @@ namespace OpenSim.Region.Physics.BulletSPlugin
        private Vector3 m_angularMotorDirection = Vector3.Zero;         // angular velocity requested by LSL motor
        // private int m_angularMotorApply = 0;                            // application frame counter
        private Vector3 m_angularMotorVelocity = Vector3.Zero;          // current angular motor velocity
-        private float m_angularMotorTimescale = 0;                      // motor angular velocity ramp up rate
+        private float m_angularMotorTimescale = 1;                      // motor angular velocity ramp up rate
-        private float m_angularMotorDecayTimescale = 0;                 // motor angular velocity decay rate
+        private float m_angularMotorDecayTimescale = 1;                 // motor angular velocity decay rate
        private Vector3 m_angularFrictionTimescale = Vector3.Zero;      // body angular velocity  decay rate
        private Vector3 m_lastAngularVelocity = Vector3.Zero;
        private Vector3 m_lastVertAttractor = Vector3.Zero;             // what VA was last applied to body
@@ -101,7 +103,7 @@ namespace OpenSim.Region.Physics.BulletSPlugin
        //Banking properties
        private float m_bankingEfficiency = 0;
-        private float m_bankingMix = 0;
+        private float m_bankingMix = 1;
        private float m_bankingTimescale = 0;
        //Hover and Buoyancy properties
@@ -122,8 +124,12 @@ namespace OpenSim.Region.Physics.BulletSPlugin
        private float m_verticalAttractionTimescale = 510f;
        // 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 PIOverFour = ((float)Math.PI) / 4f;
        static readonly float PIOverTwo = ((float)Math.PI) / 2f;
+#pragma warning restore 414
        public BSDynamics(BSScene myScene, BSPrim myPrim, string actorName)
            : base(myScene, myPrim, actorName)
@@ -155,56 +161,58 @@ namespace OpenSim.Region.Physics.BulletSPlugin
        public void ProcessFloatVehicleParam(Vehicle pParam, float pValue)
        {
            VDetailLog("{0},ProcessFloatVehicleParam,param={1},val={2}", ControllingPrim.LocalID, pParam, pValue);
+            float clampTemp;
            switch (pParam)
            {
                case Vehicle.ANGULAR_DEFLECTION_EFFICIENCY:
                    m_angularDeflectionEfficiency = ClampInRange(0f, pValue, 1f);
                    break;
                case Vehicle.ANGULAR_DEFLECTION_TIMESCALE:
-                    m_angularDeflectionTimescale = Math.Max(pValue, 0.01f);
+                    m_angularDeflectionTimescale = ClampInRange(0.25f, pValue, 120);
                    break;
                case Vehicle.ANGULAR_MOTOR_DECAY_TIMESCALE:
-                    m_angularMotorDecayTimescale = ClampInRange(0.01f, pValue, 120);
+                    m_angularMotorDecayTimescale = ClampInRange(0.25f, pValue, 120);
                    m_angularMotor.TargetValueDecayTimeScale = m_angularMotorDecayTimescale;
                    break;
                case Vehicle.ANGULAR_MOTOR_TIMESCALE:
-                    m_angularMotorTimescale = Math.Max(pValue, 0.01f);
+                    m_angularMotorTimescale = ClampInRange(0.25f, pValue, 120);
                    m_angularMotor.TimeScale = m_angularMotorTimescale;
                    break;
                case Vehicle.BANKING_EFFICIENCY:
                    m_bankingEfficiency = ClampInRange(-1f, pValue, 1f);
                    break;
                case Vehicle.BANKING_MIX:
-                    m_bankingMix = Math.Max(pValue, 0.01f);
+                    m_bankingMix = ClampInRange(0.01f, pValue, 1);
                    break;
                case Vehicle.BANKING_TIMESCALE:
-                    m_bankingTimescale = Math.Max(pValue, 0.01f);
+                    m_bankingTimescale = ClampInRange(0.25f, pValue, 120);
                    break;
                case Vehicle.BUOYANCY:
                    m_VehicleBuoyancy = ClampInRange(-1f, pValue, 1f);
                    m_VehicleGravity = ControllingPrim.ComputeGravity(m_VehicleBuoyancy);
                    break;
                case Vehicle.HOVER_EFFICIENCY:
-                    m_VhoverEfficiency = ClampInRange(0f, pValue, 1f);
+                    m_VhoverEfficiency = ClampInRange(0.01f, pValue, 1f);
                    break;
                case Vehicle.HOVER_HEIGHT:
-                    m_VhoverHeight = pValue;
+                    m_VhoverHeight = ClampInRange(0f, pValue, 1000000f);
                    break;
                case Vehicle.HOVER_TIMESCALE:
-                    m_VhoverTimescale = Math.Max(pValue, 0.01f);
+                    m_VhoverTimescale = ClampInRange(0.01f, pValue, 120);
                    break;
                case Vehicle.LINEAR_DEFLECTION_EFFICIENCY:
                    m_linearDeflectionEfficiency = ClampInRange(0f, pValue, 1f);
                    break;
                case Vehicle.LINEAR_DEFLECTION_TIMESCALE:
-                    m_linearDeflectionTimescale = Math.Max(pValue, 0.01f);
+                    m_linearDeflectionTimescale = ClampInRange(0.01f, pValue, 120);
                    break;
                case Vehicle.LINEAR_MOTOR_DECAY_TIMESCALE:
                    m_linearMotorDecayTimescale = ClampInRange(0.01f, pValue, 120);
                    m_linearMotor.TargetValueDecayTimeScale = m_linearMotorDecayTimescale;
                    break;
                case Vehicle.LINEAR_MOTOR_TIMESCALE:
-                    m_linearMotorTimescale = Math.Max(pValue, 0.01f);
+                    m_linearMotorTimescale = ClampInRange(0.01f, pValue, 120);
                    m_linearMotor.TimeScale = m_linearMotorTimescale;
                    break;
                case Vehicle.VERTICAL_ATTRACTION_EFFICIENCY:
@@ -212,30 +220,35 @@ namespace OpenSim.Region.Physics.BulletSPlugin
                    m_verticalAttractionMotor.Efficiency = m_verticalAttractionEfficiency;
                    break;
                case Vehicle.VERTICAL_ATTRACTION_TIMESCALE:
-                    m_verticalAttractionTimescale = Math.Max(pValue, 0.01f);
+                    m_verticalAttractionTimescale = ClampInRange(0.01f, pValue, 120);
                    m_verticalAttractionMotor.TimeScale = m_verticalAttractionTimescale;
                    break;
                // These are vector properties but the engine lets you use a single float value to
                // set all of the components to the same value
                case Vehicle.ANGULAR_FRICTION_TIMESCALE:
-                    m_angularFrictionTimescale = new Vector3(pValue, pValue, pValue);
+                    clampTemp = ClampInRange(0.01f, pValue, 120);
+                    m_angularFrictionTimescale = new Vector3(clampTemp, clampTemp, clampTemp);
                    break;
                case Vehicle.ANGULAR_MOTOR_DIRECTION:
-                    m_angularMotorDirection = new Vector3(pValue, pValue, pValue);
+                    clampTemp = ClampInRange(-TwoPI, pValue, TwoPI);
+                    m_angularMotorDirection = new Vector3(clampTemp, clampTemp, clampTemp);
                    m_angularMotor.Zero();
                    m_angularMotor.SetTarget(m_angularMotorDirection);
                    break;
                case Vehicle.LINEAR_FRICTION_TIMESCALE:
-                    m_linearFrictionTimescale = new Vector3(pValue, pValue, pValue);
+                    clampTemp = ClampInRange(0.01f, pValue, 120);
+                    m_linearFrictionTimescale = new Vector3(clampTemp, clampTemp, clampTemp);
                    break;
                case Vehicle.LINEAR_MOTOR_DIRECTION:
-                    m_linearMotorDirection = new Vector3(pValue, pValue, pValue);
+                    clampTemp = ClampInRange(-BSParam.MaxLinearVelocity, pValue, BSParam.MaxLinearVelocity);
-                    m_linearMotorDirectionLASTSET = new Vector3(pValue, pValue, pValue);
+                    m_linearMotorDirection = new Vector3(clampTemp, clampTemp, clampTemp);
+                    m_linearMotorDirectionLASTSET = new Vector3(clampTemp, clampTemp, clampTemp);
                    m_linearMotor.SetTarget(m_linearMotorDirection);
                    break;
                case Vehicle.LINEAR_MOTOR_OFFSET:
-                    m_linearMotorOffset = new Vector3(pValue, pValue, pValue);
+                    clampTemp = ClampInRange(-1000, pValue, 1000);
+                    m_linearMotorOffset = new Vector3(clampTemp, clampTemp, clampTemp);
                    break;
            }
@@ -247,29 +260,46 @@ namespace OpenSim.Region.Physics.BulletSPlugin
            switch (pParam)
            {
                case Vehicle.ANGULAR_FRICTION_TIMESCALE:
+                    pValue.X = ClampInRange(0.25f, pValue.X, 120);
+                    pValue.Y = ClampInRange(0.25f, pValue.Y, 120);
+                    pValue.Z = ClampInRange(0.25f, pValue.Z, 120);
                    m_angularFrictionTimescale = new Vector3(pValue.X, pValue.Y, pValue.Z);
                    break;
                case Vehicle.ANGULAR_MOTOR_DIRECTION:
                    // Limit requested angular speed to 2 rps= 4 pi rads/sec
-                    pValue.X = ClampInRange(-12.56f, pValue.X, 12.56f);
+                    pValue.X = ClampInRange(-FourPI, pValue.X, FourPI);
-                    pValue.Y = ClampInRange(-12.56f, pValue.Y, 12.56f);
+                    pValue.Y = ClampInRange(-FourPI, pValue.Y, FourPI);
-                    pValue.Z = ClampInRange(-12.56f, pValue.Z, 12.56f);
+                    pValue.Z = ClampInRange(-FourPI, pValue.Z, FourPI);
                    m_angularMotorDirection = new Vector3(pValue.X, pValue.Y, pValue.Z);
                    m_angularMotor.Zero();
                    m_angularMotor.SetTarget(m_angularMotorDirection);
                    break;
                case Vehicle.LINEAR_FRICTION_TIMESCALE:
+                    pValue.X = ClampInRange(0.25f, pValue.X, 120);
+                    pValue.Y = ClampInRange(0.25f, pValue.Y, 120);
+                    pValue.Z = ClampInRange(0.25f, pValue.Z, 120);
                    m_linearFrictionTimescale = new Vector3(pValue.X, pValue.Y, pValue.Z);
                    break;
                case Vehicle.LINEAR_MOTOR_DIRECTION:
+                    pValue.X = ClampInRange(-BSParam.MaxLinearVelocity, pValue.X, BSParam.MaxLinearVelocity);
+                    pValue.Y = ClampInRange(-BSParam.MaxLinearVelocity, pValue.Y, BSParam.MaxLinearVelocity);
+                    pValue.Z = ClampInRange(-BSParam.MaxLinearVelocity, pValue.Z, BSParam.MaxLinearVelocity);
                    m_linearMotorDirection = new Vector3(pValue.X, pValue.Y, pValue.Z);
                    m_linearMotorDirectionLASTSET = new Vector3(pValue.X, pValue.Y, pValue.Z);
                    m_linearMotor.SetTarget(m_linearMotorDirection);
                    break;
                case Vehicle.LINEAR_MOTOR_OFFSET:
+                    // Not sure the correct range to limit this variable
+                    pValue.X = ClampInRange(-1000, pValue.X, 1000);
+                    pValue.Y = ClampInRange(-1000, pValue.Y, 1000);
+                    pValue.Z = ClampInRange(-1000, pValue.Z, 1000);
                    m_linearMotorOffset = new Vector3(pValue.X, pValue.Y, pValue.Z);
                    break;
                case Vehicle.BLOCK_EXIT:
+                    // Not sure the correct range to limit this variable
+                    pValue.X = ClampInRange(-10000, pValue.X, 10000);
+                    pValue.Y = ClampInRange(-10000, pValue.Y, 10000);
+                    pValue.Z = ClampInRange(-10000, pValue.Z, 10000);
                    m_BlockingEndPoint = new Vector3(pValue.X, pValue.Y, pValue.Z);
                    break;
            }
@@ -915,7 +945,7 @@ namespace OpenSim.Region.Physics.BulletSPlugin
        {
            get
            {
-                return VehicleVelocity * Quaternion.Inverse(Quaternion.Normalize(VehicleOrientation));
+                return VehicleVelocity * Quaternion.Inverse(Quaternion.Normalize(VehicleFrameOrientation));
            }
        }
@@ -926,6 +956,13 @@ namespace OpenSim.Region.Physics.BulletSPlugin
                return VehicleForwardVelocity.X;
            }
        }
+        private Quaternion VehicleFrameOrientation
+        {
+            get
+            {
+                return VehicleOrientation * m_referenceFrame;
+            }
+        }
        #endregion // Known vehicle value functions
@@ -1011,8 +1048,13 @@ namespace OpenSim.Region.Physics.BulletSPlugin
                VDetailLog("{0},  MoveLinear,clampMax,origVelW={1},lenSq={2},maxVelSq={3},,newVelW={4}",
                            ControllingPrim.LocalID, origVelW, newVelocityLengthSq, BSParam.VehicleMaxLinearVelocitySquared, VehicleVelocity);
            }
-            else if (newVelocityLengthSq < 0.001f)
+            else if (newVelocityLengthSq < BSParam.VehicleMinLinearVelocitySquared)
+            {
+                Vector3 origVelW = VehicleVelocity;         // DEBUG DEBUG
+                VDetailLog("{0},  MoveLinear,clampMin,origVelW={1},lenSq={2}",
+                            ControllingPrim.LocalID, origVelW, newVelocityLengthSq);
                VehicleVelocity = Vector3.Zero;
+            }
            VDetailLog("{0},  MoveLinear,done,isColl={1},newVel={2}", ControllingPrim.LocalID, ControllingPrim.HasSomeCollision, VehicleVelocity );
@@ -1030,7 +1072,7 @@ namespace OpenSim.Region.Physics.BulletSPlugin
            linearMotorCorrectionV -= (currentVelV * frictionFactorV);
            // Motor is vehicle coordinates. Rotate it to world coordinates
-            Vector3 linearMotorVelocityW = linearMotorCorrectionV * VehicleOrientation;
+            Vector3 linearMotorVelocityW = linearMotorCorrectionV * VehicleFrameOrientation;
            // If we're a ground vehicle, don't add any upward Z movement
            if ((m_flags & VehicleFlag.LIMIT_MOTOR_UP) != 0)
@@ -1072,7 +1114,7 @@ namespace OpenSim.Region.Physics.BulletSPlugin
                linearDeflectionV *= new Vector3(1, -1, -1);
                // Correction is vehicle relative. Convert to world coordinates.
-                Vector3 linearDeflectionW = linearDeflectionV * VehicleOrientation;
+                Vector3 linearDeflectionW = linearDeflectionV * VehicleFrameOrientation;
                // Optionally, if not colliding, don't effect world downward velocity. Let falling things fall.
                if (BSParam.VehicleLinearDeflectionNotCollidingNoZ && !m_controllingPrim.HasSomeCollision)
@@ -1106,7 +1148,7 @@ namespace OpenSim.Region.Physics.BulletSPlugin
        {
            // m_VhoverEfficiency: 0=bouncy, 1=totally damped
            // m_VhoverTimescale: time to achieve height
-            if ((m_flags & (VehicleFlag.HOVER_WATER_ONLY | VehicleFlag.HOVER_TERRAIN_ONLY | VehicleFlag.HOVER_GLOBAL_HEIGHT)) != 0)
+            if ((m_flags & (VehicleFlag.HOVER_WATER_ONLY | VehicleFlag.HOVER_TERRAIN_ONLY | VehicleFlag.HOVER_GLOBAL_HEIGHT)) != 0 && (m_VhoverHeight > 0) && (m_VhoverTimescale < 300))
            {
                // We should hover, get the target height
                if ((m_flags & VehicleFlag.HOVER_WATER_ONLY) != 0)
@@ -1368,7 +1410,7 @@ namespace OpenSim.Region.Physics.BulletSPlugin
        {
            // The user wants this many radians per second angular change?
            Vector3 origVehicleRotationalVelocity = VehicleRotationalVelocity;      // DEBUG DEBUG
-            Vector3 currentAngularV = VehicleRotationalVelocity * Quaternion.Inverse(VehicleOrientation);
+            Vector3 currentAngularV = VehicleRotationalVelocity * Quaternion.Inverse(VehicleFrameOrientation);
            Vector3 angularMotorContributionV = m_angularMotor.Step(pTimestep, currentAngularV);
            // ==================================================================
@@ -1389,7 +1431,7 @@ namespace OpenSim.Region.Physics.BulletSPlugin
            Vector3 frictionFactorW = ComputeFrictionFactor(m_angularFrictionTimescale, pTimestep);
            angularMotorContributionV -= (currentAngularV * frictionFactorW);
-            Vector3 angularMotorContributionW = angularMotorContributionV * VehicleOrientation;
+            Vector3 angularMotorContributionW = angularMotorContributionV * VehicleFrameOrientation;
            VehicleRotationalVelocity += angularMotorContributionW;
            VDetailLog("{0},  MoveAngular,angularTurning,curAngVelV={1},origVehRotVel={2},vehRotVel={3},frictFact={4}, angContribV={5},angContribW={6}",
@@ -1410,7 +1452,7 @@ namespace OpenSim.Region.Physics.BulletSPlugin
            // If vertical attaction timescale is reasonable
            if (BSParam.VehicleEnableAngularVerticalAttraction && m_verticalAttractionTimescale < m_verticalAttractionCutoff)
            {
-                Vector3 vehicleUpAxis = Vector3.UnitZ * VehicleOrientation;
+                Vector3 vehicleUpAxis = Vector3.UnitZ * VehicleFrameOrientation;
                switch (BSParam.VehicleAngularVerticalAttractionAlgorithm)
                {
                    case 0:
@@ -1429,6 +1471,12 @@ namespace OpenSim.Region.Physics.BulletSPlugin
                            // This is only half the distance to the target so it will take 2 seconds to complete the turn.
                            Vector3 torqueVector = Vector3.Cross(predictedUp, Vector3.UnitZ);
+                            if ((m_flags & VehicleFlag.LIMIT_ROLL_ONLY) != 0)
+                            {
+                                Vector3 vehicleForwardAxis = Vector3.UnitX * VehicleFrameOrientation;
+                                torqueVector = ProjectVector(torqueVector, vehicleForwardAxis);
+                            }
                            // Scale vector by our timescale since it is an acceleration it is r/s^2 or radians a timescale squared
                            Vector3 vertContributionV = torqueVector * verticalAttractionSpeed * verticalAttractionSpeed;
@@ -1450,13 +1498,13 @@ namespace OpenSim.Region.Physics.BulletSPlugin
                            // Create a rotation that is only the vehicle's rotation around Z
                            Vector3 currentEulerW = Vector3.Zero;
-                            VehicleOrientation.GetEulerAngles(out currentEulerW.X, out currentEulerW.Y, out currentEulerW.Z);
+                            VehicleFrameOrientation.GetEulerAngles(out currentEulerW.X, out currentEulerW.Y, out currentEulerW.Z);
                            Quaternion justZOrientation = Quaternion.CreateFromAxisAngle(Vector3.UnitZ, currentEulerW.Z);
                            // Create the axis that is perpendicular to the up vector and the rotated up vector.
-                            Vector3 differenceAxisW = Vector3.Cross(Vector3.UnitZ * justZOrientation, Vector3.UnitZ * VehicleOrientation);
+                            Vector3 differenceAxisW = Vector3.Cross(Vector3.UnitZ * justZOrientation, Vector3.UnitZ * VehicleFrameOrientation);
                            // Compute the angle between those to vectors.
-                            double differenceAngle = Math.Acos((double)Vector3.Dot(Vector3.UnitZ, Vector3.Normalize(Vector3.UnitZ * VehicleOrientation)));
+                            double differenceAngle = Math.Acos((double)Vector3.Dot(Vector3.UnitZ, Vector3.Normalize(Vector3.UnitZ * VehicleFrameOrientation)));
                            // 'differenceAngle' is the angle to rotate and 'differenceAxis' is the plane to rotate in to get the vehicle vertical
                            // Reduce the change by the time period it is to change in. Timestep is handled when velocity is applied.
@@ -1489,7 +1537,7 @@ namespace OpenSim.Region.Physics.BulletSPlugin
                            Vector3 origRotVelW = VehicleRotationalVelocity;        // DEBUG DEBUG
                            // Take a vector pointing up and convert it from world to vehicle relative coords.
-                            Vector3 verticalError = Vector3.Normalize(Vector3.UnitZ * VehicleOrientation);
+                            Vector3 verticalError = Vector3.Normalize(Vector3.UnitZ * VehicleFrameOrientation);
                            // If vertical attraction correction is needed, the vector that was pointing up (UnitZ)
                            //    is now:
@@ -1520,7 +1568,7 @@ namespace OpenSim.Region.Physics.BulletSPlugin
                            vertContributionV /= m_verticalAttractionTimescale;
                            // Rotate the vehicle rotation to the world coordinates.
-                            VehicleRotationalVelocity += (vertContributionV * VehicleOrientation);
+                            VehicleRotationalVelocity += (vertContributionV * VehicleFrameOrientation);
                            VDetailLog("{0},  MoveAngular,verticalAttraction,,upAxis={1},origRotVW={2},vertError={3},unscaledV={4},eff={5},ts={6},vertContribV={7}",
                                            ControllingPrim.LocalID,
@@ -1561,7 +1609,7 @@ namespace OpenSim.Region.Physics.BulletSPlugin
                movingDirection *= Math.Sign(VehicleForwardSpeed);
                // The direction the vehicle is pointing
-                Vector3 pointingDirection = Vector3.UnitX * VehicleOrientation;
+                Vector3 pointingDirection = Vector3.UnitX * VehicleFrameOrientation;
                //Predict where the Vehicle will be pointing after AngularVelocity change is applied. This will keep
                //   from overshooting and allow this correction to merge with the Vertical Attraction peacefully.
                Vector3 predictedPointingDirection = pointingDirection * Quaternion.CreateFromAxisAngle(VehicleRotationalVelocity, 0f);
@@ -1586,7 +1634,6 @@ namespace OpenSim.Region.Physics.BulletSPlugin
                deflectContributionV = (-deflectionError) * ClampInRange(0, m_angularDeflectionEfficiency/m_angularDeflectionTimescale,1f);
                //deflectContributionV /= m_angularDeflectionTimescale;
-               // VehicleRotationalVelocity += deflectContributionV * VehicleOrientation;
                VehicleRotationalVelocity += deflectContributionV;
                VDetailLog("{0},  MoveAngular,Deflection,movingDir={1},pointingDir={2},deflectError={3},ret={4}",
                    ControllingPrim.LocalID, movingDirection, pointingDirection, deflectionError, deflectContributionV);
@@ -1635,7 +1682,7 @@ namespace OpenSim.Region.Physics.BulletSPlugin
                // Rotate a UnitZ vector (pointing up) to how the vehicle is oriented.
                // As the vehicle rolls to the right or left, the Y value will increase from
                //     zero (straight up) to 1 or -1 (full tilt right  or left)
-                Vector3 rollComponents = Vector3.UnitZ * VehicleOrientation;
+                Vector3 rollComponents = Vector3.UnitZ * VehicleFrameOrientation;
                // Figure out the yaw value for this much roll.
                float yawAngle = m_angularMotorDirection.X * m_bankingEfficiency;
@@ -1644,7 +1691,7 @@ namespace OpenSim.Region.Physics.BulletSPlugin
                // TODO: the banking effect should not go to infinity but what to limit it to?
                //     And what should happen when this is being added to a user defined yaw that is already PI*4?
-                mixedYawAngle = ClampInRange(-12, mixedYawAngle, 12);
+                mixedYawAngle = ClampInRange(-FourPI, mixedYawAngle, FourPI);
                // Build the force vector to change rotation from what it is to what it should be
                bankingContributionV.Z = -mixedYawAngle;
@@ -1652,7 +1699,6 @@ namespace OpenSim.Region.Physics.BulletSPlugin
                // Don't do it all at once. Fudge because 1 second is too fast with most user defined roll as PI*4.
                bankingContributionV /= m_bankingTimescale * BSParam.VehicleAngularBankingTimescaleFudge;
-                //VehicleRotationalVelocity += bankingContributionV * VehicleOrientation;
                VehicleRotationalVelocity += bankingContributionV;
@@ -1730,6 +1776,14 @@ namespace OpenSim.Region.Physics.BulletSPlugin
        }
+        //Given a Vector and a unit vector will return the amount of the vector is on the same axis as the unit.
+        private Vector3 ProjectVector(Vector3 vector, Vector3 onNormal)
+        {
+            float vectorDot = Vector3.Dot(vector, onNormal);
+            return onNormal * vectorDot;
+        }
        private float ClampInRange(float low, float val, float high)
        {
            return Math.Max(low, Math.Min(val, high));
diff --git a/OpenSim/Region/Physics/BulletSPlugin/BSLinkset.cs b/OpenSim/Region/Physics/BulletSPlugin/BSLinkset.cs
index 77f69a5..87eba33 100755
--- a/OpenSim/Region/Physics/BulletSPlugin/BSLinkset.cs
+++ b/OpenSim/Region/Physics/BulletSPlugin/BSLinkset.cs
@@ -1,4 +1,4 @@
-/*
+/*
 * Copyright (c) Contributors, http://opensimulator.org/
 * See CONTRIBUTORS.TXT for a full list of copyright holders.
 *
@@ -128,6 +128,7 @@ public abstract class BSLinkset
        m_children = new Dictionary<BSPrimLinkable, BSLinkInfo>();
        LinksetMass = parent.RawMass;
        Rebuilding = false;
+        RebuildScheduled = false;
        parent.ClearDisplacement();
    }
@@ -297,8 +298,16 @@ public abstract class BSLinkset
    // Flag denoting the linkset is in the process of being rebuilt.
    // Used to know not the schedule a rebuild in the middle of a rebuild.
+    // Because of potential update calls that could want to schedule another rebuild.
    protected bool Rebuilding { get; set; }
+    // Flag saying a linkset rebuild has been scheduled.
+    // This is turned on when the rebuild is requested and turned off when
+    //     the rebuild is complete. Used to limit modifications to the
+    //     linkset parameters while the linkset is in an intermediate state.
+    // Protected by a "lock(m_linsetActivityLock)" on the BSLinkset object
+    public bool RebuildScheduled { get; protected set; }
    // The object is going dynamic (physical). Do any setup necessary
    //     for a dynamic linkset.
    // Only the state of the passed object can be modified. The rest of the linkset
@@ -307,6 +316,23 @@ public abstract class BSLinkset
    // Called at taint-time!
    public abstract bool MakeDynamic(BSPrimLinkable child);
+    public virtual bool AllPartsComplete
+    {
+        get {
+            bool ret = true; 
+            this.ForEachMember((member) =>
+            {
+                if ((!member.IsInitialized) || member.IsIncomplete || member.PrimAssetState == BSPhysObject.PrimAssetCondition.Waiting)
+                {
+                    ret = false;
+                    return true;    // exit loop
+                }
+                return false;       // continue loop
+            });
+            return ret;
+        }
+    }
    // The object is going static (non-physical). Do any setup necessary
    //     for a static linkset.
    // Return 'true' if any properties updated on the passed object.
diff --git a/OpenSim/Region/Physics/BulletSPlugin/BSLinksetCompound.cs b/OpenSim/Region/Physics/BulletSPlugin/BSLinksetCompound.cs
index 8f12189..cae9efa 100755
--- a/OpenSim/Region/Physics/BulletSPlugin/BSLinksetCompound.cs
+++ b/OpenSim/Region/Physics/BulletSPlugin/BSLinksetCompound.cs
@@ -37,7 +37,9 @@ namespace OpenSim.Region.Physics.BulletSPlugin
 public sealed class BSLinksetCompound : BSLinkset
 {
+#pragma warning disable 414
    private static string LogHeader = "[BULLETSIM LINKSET COMPOUND]";
+#pragma warning restore 414
    public BSLinksetCompound(BSScene scene, BSPrimLinkable parent)
        : base(scene, parent)
@@ -98,22 +100,43 @@ public sealed class BSLinksetCompound : BSLinkset
    // Schedule a refresh to happen after all the other taint processing.
    private void ScheduleRebuild(BSPrimLinkable requestor)
    {
-        DetailLog("{0},BSLinksetCompound.ScheduleRebuild,,rebuilding={1},hasChildren={2},actuallyScheduling={3}",
-                            requestor.LocalID, Rebuilding, HasAnyChildren, (!Rebuilding && HasAnyChildren));
        // When rebuilding, it is possible to set properties that would normally require a rebuild.
        //    If already rebuilding, don't request another rebuild.
        //    If a linkset with just a root prim (simple non-linked prim) don't bother rebuilding.
-        if (!Rebuilding && HasAnyChildren)
+        lock (m_linksetActivityLock)
        {
-            m_physicsScene.PostTaintObject("BSLinksetCompound.ScheduleRebuild", LinksetRoot.LocalID, delegate()
+            if (!RebuildScheduled && !Rebuilding && HasAnyChildren)
            {
-                if (HasAnyChildren)
+                InternalScheduleRebuild(requestor);
-                    RecomputeLinksetCompound();
+            }
-            });
        }
    }
+    // Must be called with m_linksetActivityLock or race conditions will haunt you.
+    private void InternalScheduleRebuild(BSPrimLinkable requestor)
+    {
+        DetailLog("{0},BSLinksetCompound.InternalScheduleRebuild,,rebuilding={1},hasChildren={2}",
+                            requestor.LocalID, Rebuilding, HasAnyChildren);
+        RebuildScheduled = true;
+        m_physicsScene.PostTaintObject("BSLinksetCompound.ScheduleRebuild", LinksetRoot.LocalID, delegate()
+        {
+            if (HasAnyChildren)
+            {
+                if (this.AllPartsComplete)
+                {
+                    RecomputeLinksetCompound();
+                }
+                else
+                {
+                    DetailLog("{0},BSLinksetCompound.InternalScheduleRebuild,,rescheduling because not all children complete",
+                                                    requestor.LocalID);
+                    InternalScheduleRebuild(requestor);
+                }
+            }
+            RebuildScheduled = false;
+        });
+    }
    // The object is going dynamic (physical). Do any setup necessary for a dynamic linkset.
    // Only the state of the passed object can be modified. The rest of the linkset
    //     has not yet been fully constructed.
@@ -178,7 +201,10 @@ public sealed class BSLinksetCompound : BSLinkset
            if ((whichUpdated & ~(UpdatedProperties.Position | UpdatedProperties.Orientation)) == 0)
            {
                // Find the physical instance of the child
-                if (LinksetRoot.PhysShape.HasPhysicalShape && m_physicsScene.PE.IsCompound(LinksetRoot.PhysShape.physShapeInfo))
+                if (!RebuildScheduled   // if rebuilding, let the rebuild do it
+                        && !LinksetRoot.IsIncomplete    // if waiting for assets or whatever, don't change
+                        && LinksetRoot.PhysShape.HasPhysicalShape   // there must be a physical shape assigned
+                        && m_physicsScene.PE.IsCompound(LinksetRoot.PhysShape.physShapeInfo))
                {
                    // It is possible that the linkset is still under construction and the child is not yet
                    //    inserted into the compound shape. A rebuild of the linkset in a pre-step action will
@@ -369,23 +395,47 @@ public sealed class BSLinksetCompound : BSLinkset
                // Get a reference to the shape of the child for adding of that shape to the linkset compound shape
                BSShape childShape = cPrim.PhysShape.GetReference(m_physicsScene, cPrim);
-                // Offset the child shape from the center-of-mass and rotate it to vehicle relative.
+                // Offset the child shape from the center-of-mass and rotate it to root relative.
                OMV.Vector3 offsetPos = (cPrim.RawPosition - origRootPosition) * invRootOrientation - centerDisplacementV;
                OMV.Quaternion offsetRot = OMV.Quaternion.Normalize(cPrim.RawOrientation) * invRootOrientation;
                // Add the child shape to the compound shape being built
-                m_physicsScene.PE.AddChildShapeToCompoundShape(linksetShape.physShapeInfo, childShape.physShapeInfo, offsetPos, offsetRot);
+                if (childShape.physShapeInfo.HasPhysicalShape)
-                DetailLog("{0},BSLinksetCompound.RecomputeLinksetCompound,addChild,indx={1},cShape={2},offPos={3},offRot={4}",
+                {
-                                    LinksetRoot.LocalID, cPrim.LinksetChildIndex, childShape, offsetPos, offsetRot);
+                    m_physicsScene.PE.AddChildShapeToCompoundShape(linksetShape.physShapeInfo, childShape.physShapeInfo, offsetPos, offsetRot);
+                    DetailLog("{0},BSLinksetCompound.RecomputeLinksetCompound,addChild,indx={1},cShape={2},offPos={3},offRot={4}",
+                                LinksetRoot.LocalID, cPrim.LinksetChildIndex, childShape, offsetPos, offsetRot);
-                // Since we are borrowing the shape of the child, disable the origional child body
+                    // Since we are borrowing the shape of the child, disable the origional child body
-                if (!IsRoot(cPrim))
+                    if (!IsRoot(cPrim))
+                    {
+                        m_physicsScene.PE.AddToCollisionFlags(cPrim.PhysBody, CollisionFlags.CF_NO_CONTACT_RESPONSE);
+                        m_physicsScene.PE.ForceActivationState(cPrim.PhysBody, ActivationState.DISABLE_SIMULATION);
+                        // We don't want collisions from the old linkset children.
+                        m_physicsScene.PE.RemoveFromCollisionFlags(cPrim.PhysBody, CollisionFlags.BS_SUBSCRIBE_COLLISION_EVENTS);
+                        cPrim.PhysBody.collisionType = CollisionType.LinksetChild;
+                    }
+                }
+                else
                {
-                    m_physicsScene.PE.AddToCollisionFlags(cPrim.PhysBody, CollisionFlags.CF_NO_CONTACT_RESPONSE);
+                    // The linkset must be in an intermediate state where all the children have not yet
-                    m_physicsScene.PE.ForceActivationState(cPrim.PhysBody, ActivationState.DISABLE_SIMULATION);
+                    //    been constructed. This sometimes happens on startup when everything is getting
-                    // We don't want collisions from the old linkset children.
+                    //    built and some shapes have to wait for assets to be read in.
-                    m_physicsScene.PE.RemoveFromCollisionFlags(cPrim.PhysBody, CollisionFlags.BS_SUBSCRIBE_COLLISION_EVENTS);
+                    // Just skip this linkset for the moment and cause the shape to be rebuilt next tick.
-                    cPrim.PhysBody.collisionType = CollisionType.LinksetChild;
+                    // One problem might be that the shape is broken somehow and it never becomes completely
+                    //    available. This might cause the rebuild to happen over and over.
+                    InternalScheduleRebuild(LinksetRoot);
+                    DetailLog("{0},BSLinksetCompound.RecomputeLinksetCompound,addChildWithNoShape,indx={1},cShape={2},offPos={3},offRot={4}",
+                                    LinksetRoot.LocalID, cPrim.LinksetChildIndex, childShape, offsetPos, offsetRot);
+                    // Output an annoying warning. It should only happen once but if it keeps coming out,
+                    //    the user knows there is something wrong and will report it.
+                    m_physicsScene.Logger.WarnFormat("{0} Linkset rebuild warning. If this happens more than one or two times, please report in Mantis 7191", LogHeader);
+                    m_physicsScene.Logger.WarnFormat("{0} pName={1}, childIdx={2}, shape={3}",
+                                    LogHeader, LinksetRoot.Name, cPrim.LinksetChildIndex, childShape);
+                    // This causes the loop to bail on building the rest of this linkset.
+                    // The rebuild operation will fix it up next tick or declare the object unbuildable.
+                    return true;
                }
                return false;   // 'false' says to move onto the next child in the list
diff --git a/OpenSim/Region/Physics/BulletSPlugin/BSLinksetConstraints.cs b/OpenSim/Region/Physics/BulletSPlugin/BSLinksetConstraints.cs
index aaf92c8..4384cdc 100755
--- a/OpenSim/Region/Physics/BulletSPlugin/BSLinksetConstraints.cs
+++ b/OpenSim/Region/Physics/BulletSPlugin/BSLinksetConstraints.cs
@@ -78,7 +78,7 @@ public sealed class BSLinksetConstraints : BSLinkset
        public override void ResetLink()
        {
            // constraintType = ConstraintType.D6_CONSTRAINT_TYPE;
-            constraintType = ConstraintType.FIXED_CONSTRAINT_TYPE;
+            constraintType = ConstraintType.BS_FIXED_CONSTRAINT_TYPE;
            linearLimitLow = OMV.Vector3.Zero;
            linearLimitHigh = OMV.Vector3.Zero;
            angularLimitLow = OMV.Vector3.Zero;
@@ -115,7 +115,7 @@ public sealed class BSLinksetConstraints : BSLinkset
            member.PhysScene.DetailLog("{0},BSLinkInfoConstraint.SetLinkParameters,type={1}", member.LocalID, constraintType);
            switch (constraintType)
            {
-                case ConstraintType.FIXED_CONSTRAINT_TYPE:
+                case ConstraintType.BS_FIXED_CONSTRAINT_TYPE:
                case ConstraintType.D6_CONSTRAINT_TYPE:
                    BSConstraint6Dof constrain6dof = constrain as BSConstraint6Dof;
                    if (constrain6dof != null)
@@ -179,7 +179,7 @@ public sealed class BSLinksetConstraints : BSLinkset
        public override bool ShouldUpdateChildProperties()
        {
            bool ret = true;
-            if (constraintType == ConstraintType.FIXED_CONSTRAINT_TYPE)
+            if (constraintType == ConstraintType.BS_FIXED_CONSTRAINT_TYPE)
                ret = false;
            return ret;
@@ -212,20 +212,28 @@ public sealed class BSLinksetConstraints : BSLinkset
        // When rebuilding, it is possible to set properties that would normally require a rebuild.
        //    If already rebuilding, don't request another rebuild.
        //    If a linkset with just a root prim (simple non-linked prim) don't bother rebuilding.
-        if (!Rebuilding && HasAnyChildren)
+        lock (this)
        {
-            // Queue to happen after all the other taint processing
+            if (!RebuildScheduled)
-            m_physicsScene.PostTaintObject("BSLinksetContraints.Refresh", requestor.LocalID, delegate()
            {
-                if (HasAnyChildren)
+                if (!Rebuilding && HasAnyChildren)
                {
-                    // Constraints that have not been changed are not rebuild but make sure
+                    RebuildScheduled = true;
-                    //     the constraint of the requestor is rebuilt.
+                    // Queue to happen after all the other taint processing
-                    PhysicallyUnlinkAChildFromRoot(LinksetRoot, requestor);
+                    m_physicsScene.PostTaintObject("BSLinksetContraints.Refresh", requestor.LocalID, delegate()
-                    // Rebuild the linkset and all its constraints.
+                    {
-                    RecomputeLinksetConstraints();
+                        if (HasAnyChildren)
+                        {
+                            // Constraints that have not been changed are not rebuild but make sure
+                            //     the constraint of the requestor is rebuilt.
+                            PhysicallyUnlinkAChildFromRoot(LinksetRoot, requestor);
+                            // Rebuild the linkset and all its constraints.
+                            RecomputeLinksetConstraints();
+                        }
+                        RebuildScheduled = false;
+                    });
                }
-            });
+            }
        }
    }
@@ -363,7 +371,7 @@ public sealed class BSLinksetConstraints : BSLinkset
        switch (linkInfo.constraintType)
        {
-            case ConstraintType.FIXED_CONSTRAINT_TYPE:
+            case ConstraintType.BS_FIXED_CONSTRAINT_TYPE:
            case ConstraintType.D6_CONSTRAINT_TYPE:
                // Relative position normalized to the root prim
                // Essentually a vector pointing from center of rootPrim to center of li.member
@@ -536,7 +544,7 @@ public sealed class BSLinksetConstraints : BSLinkset
                {
                    int requestedType = (int)pParams[2];
                    DetailLog("{0},BSLinksetConstraint.ChangeLinkType,requestedType={1}", LinksetRoot.LocalID, requestedType);
-                    if (requestedType == (int)ConstraintType.FIXED_CONSTRAINT_TYPE
+                    if (requestedType == (int)ConstraintType.BS_FIXED_CONSTRAINT_TYPE
                        || requestedType == (int)ConstraintType.D6_CONSTRAINT_TYPE
                        || requestedType == (int)ConstraintType.D6_SPRING_CONSTRAINT_TYPE
                        || requestedType == (int)ConstraintType.HINGE_CONSTRAINT_TYPE
@@ -646,7 +654,7 @@ public sealed class BSLinksetConstraints : BSLinkset
                                        case ExtendedPhysics.PHYS_PARAM_LINK_TYPE:
                                            valueInt = (int)pParams[opIndex + 1];
                                            ConstraintType valueType = (ConstraintType)valueInt;
-                                            if (valueType == ConstraintType.FIXED_CONSTRAINT_TYPE
+                                            if (valueType == ConstraintType.BS_FIXED_CONSTRAINT_TYPE
                                                || valueType == ConstraintType.D6_CONSTRAINT_TYPE
                                                || valueType == ConstraintType.D6_SPRING_CONSTRAINT_TYPE
                                                || valueType == ConstraintType.HINGE_CONSTRAINT_TYPE
diff --git a/OpenSim/Region/Physics/BulletSPlugin/BSParam.cs b/OpenSim/Region/Physics/BulletSPlugin/BSParam.cs
index 834228e..6d46fe6 100755
--- a/OpenSim/Region/Physics/BulletSPlugin/BSParam.cs
+++ b/OpenSim/Region/Physics/BulletSPlugin/BSParam.cs
@@ -54,6 +54,14 @@ public static class BSParam
    // ===================
    // From:
+    /// <summary>
+    /// Set whether physics is active or not.
+    /// </summary>
+    /// <remarks>
+    /// Can be enabled and disabled to start and stop physics.
+    /// </remarks>
+    public static bool Active { get; private set; }
    public static bool UseSeparatePhysicsThread { get; private set; }
    public static float PhysicsTimeStep { get; private set; }
@@ -97,6 +105,7 @@ public static class BSParam
    public static float TerrainImplementation { get; set; }
    public static int TerrainMeshMagnification { get; private set; }
+    public static float TerrainGroundPlane { get; private set; }
    public static float TerrainFriction { get; private set; }
    public static float TerrainHitFraction { get; private set; }
    public static float TerrainRestitution { get; private set; }
@@ -123,22 +132,29 @@ public static class BSParam
    public static float PhysicsUnmanLoggingFrames { get; private set; }
    // Avatar parameters
+    public static bool AvatarToAvatarCollisionsByDefault { get; private set; }
    public static float AvatarFriction { get; private set; }
    public static float AvatarStandingFriction { get; private set; }
    public static float AvatarAlwaysRunFactor { get; private set; }
    public static float AvatarDensity { get; private set; }
    public static float AvatarRestitution { get; private set; }
+    public static int AvatarShape { get; private set; }
    public static float AvatarCapsuleWidth { get; private set; }
    public static float AvatarCapsuleDepth { get; private set; }
    public static float AvatarCapsuleHeight { get; private set; }
    public static float AvatarHeightLowFudge { get; private set; }
    public static float AvatarHeightMidFudge { get; private set; }
    public static float AvatarHeightHighFudge { get; private set; }
+    public static float 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 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; }
@@ -147,6 +163,8 @@ public static class BSParam
    // Vehicle parameters
    public static float VehicleMaxLinearVelocity { get; private set; }
    public static float VehicleMaxLinearVelocitySquared { get; private set; }
+    public static float VehicleMinLinearVelocity { get; private set; }
+    public static float VehicleMinLinearVelocitySquared { get; private set; }
    public static float VehicleMaxAngularVelocity { get; private set; }
    public static float VehicleMaxAngularVelocitySq { get; private set; }
    public static float VehicleAngularDamping { get; private set; }
@@ -165,6 +183,7 @@ public static class BSParam
    public static bool VehicleEnableAngularBanking { get; private set; }
    // Convex Hulls
+    // Parameters for convex hull routine that ships with Bullet
    public static int CSHullMaxDepthSplit { get; private set; }
    public static int CSHullMaxDepthSplitForSimpleShapes { get; private set; }
    public static float CSHullConcavityThresholdPercent { get; private set; }
@@ -180,6 +199,22 @@ public static class BSParam
        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
    // Linkset implementation parameters
    public static float LinksetImplementation { get; private set; }
@@ -366,6 +401,8 @@ public static class BSParam
    //    v = value (appropriate type)
    private static ParameterDefnBase[] ParameterDefinitions =
    {
+        new ParameterDefn<bool>("Active", "If 'true', false then physics is not active",
+            false ),
        new ParameterDefn<bool>("UseSeparatePhysicsThread", "If 'true', the physics engine runs independent from the simulator heartbeat",
            false ),
        new ParameterDefn<float>("PhysicsTimeStep", "If separate thread, seconds to simulate each interval",
@@ -538,9 +575,11 @@ public static class BSParam
            (s,o) => { s.PE.SetContactProcessingThreshold(o.PhysBody, ContactProcessingThreshold); } ),
            new ParameterDefn<float>("TerrainImplementation", "Type of shape to use for terrain (0=heightmap, 1=mesh)",
-            (float)BSTerrainPhys.TerrainImplementation.Mesh ),
+            (float)BSTerrainPhys.TerrainImplementation.Heightmap ),
        new ParameterDefn<int>("TerrainMeshMagnification", "Number of times the 256x256 heightmap is multiplied to create the terrain mesh" ,
            2 ),
+        new ParameterDefn<float>("TerrainGroundPlane", "Altitude of ground plane used to keep things from falling to infinity" ,
+            -500.0f ),
        new ParameterDefn<float>("TerrainFriction", "Factor to reduce movement against terrain surface" ,
            0.3f ),
        new ParameterDefn<float>("TerrainHitFraction", "Distance to measure hit collisions" ,
@@ -550,8 +589,10 @@ public static class BSParam
        new ParameterDefn<float>("TerrainContactProcessingThreshold", "Distance from terrain to stop processing collisions" ,
            0.0f ),
        new ParameterDefn<float>("TerrainCollisionMargin", "Margin where collision checking starts" ,
-            0.08f ),
+            0.04f ),
+        new ParameterDefn<bool>("AvatarToAvatarCollisionsByDefault", "Should avatars collide with other avatars by default?",
+            true),
        new ParameterDefn<float>("AvatarFriction", "Factor to reduce movement against an avatar. Changed on avatar recreation.",
            0.2f ),
        new ParameterDefn<float>("AvatarStandingFriction", "Avatar friction when standing. Changed on avatar recreation.",
@@ -563,6 +604,8 @@ public static class BSParam
            3500f) ,    // 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",
+            BSShapeCollection.AvatarShapeCube ) ,
        new ParameterDefn<float>("AvatarCapsuleWidth", "The distance between the sides of the avatar capsule",
            0.6f ) ,
        new ParameterDefn<float>("AvatarCapsuleDepth", "The distance between the front and back of the avatar capsule",
@@ -570,11 +613,17 @@ public static class BSParam
        new ParameterDefn<float>("AvatarCapsuleHeight", "Default height of space around avatar",
            1.5f ),
        new ParameterDefn<float>("AvatarHeightLowFudge", "A fudge factor to make small avatars stand on the ground",
-            -0.2f ),
+            0f ),
        new ParameterDefn<float>("AvatarHeightMidFudge", "A fudge distance to adjust average sized avatars to be standing on ground",
-            0.1f ),
+            0f ),
        new ParameterDefn<float>("AvatarHeightHighFudge", "A fudge factor to make tall avatars stand on the ground",
-            0.1f ),
+            0f ),
+        new ParameterDefn<float>("AvatarFlyingGroundMargin", "Meters avatar is kept above the ground when flying",
+            5f ),
+        new ParameterDefn<float>("AvatarFlyingGroundUpForce", "Upward force applied to the avatar to keep it at flying ground margin",
+            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",
@@ -584,20 +633,28 @@ public static class BSParam
            new ParameterDefn<int>("AvatarJumpFrames", "Number of frames to allow jump forces. Changes jump height.",
            4 ),
            new ParameterDefn<float>("AvatarStepHeight", "Height of a step obstacle to consider step correction",
-            0.6f ) ,
+            0.999f ) ,
+            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",
+            0.1f ) ,
            new ParameterDefn<float>("AvatarStepApproachFactor", "Factor to control angle of approach to step (0=straight on)",
-            0.6f ),
+            2f ),
            new ParameterDefn<float>("AvatarStepForceFactor", "Controls the amount of force up applied to step up onto a step",
-            1.0f ),
+            0f ),
            new ParameterDefn<float>("AvatarStepUpCorrectionFactor", "Multiplied by height of step collision to create up movement at step",
-            1.0f ),
+            0.8f ),
            new ParameterDefn<int>("AvatarStepSmoothingSteps", "Number of frames after a step collision that we continue walking up stairs",
-            2 ),
+            1 ),
        new ParameterDefn<float>("VehicleMaxLinearVelocity", "Maximum velocity magnitude that can be assigned to a vehicle",
            1000.0f,
            (s) => { return (float)VehicleMaxLinearVelocity; },
            (s,v) => { VehicleMaxLinearVelocity = v; VehicleMaxLinearVelocitySquared = v * v; } ),
+        new ParameterDefn<float>("VehicleMinLinearVelocity", "Maximum velocity magnitude that can be assigned to a vehicle",
+            0.001f,
+            (s) => { return (float)VehicleMinLinearVelocity; },
+            (s,v) => { VehicleMinLinearVelocity = v; VehicleMinLinearVelocitySquared = v * v; } ),
        new ParameterDefn<float>("VehicleMaxAngularVelocity", "Maximum rotational velocity magnitude that can be assigned to a vehicle",
            12.0f,
            (s) => { return (float)VehicleMaxAngularVelocity; },
@@ -709,6 +766,33 @@ public static class BSParam
            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",
+            0f ),
+            new ParameterDefn<float>("VHACDresolution", "max number of voxels generated during voxelization stage",
+            100000f ),
+            new ParameterDefn<float>("VHACDdepth", "max number of clipping stages",
+            20f ),
+            new ParameterDefn<float>("VHACDconcavity", "maximum concavity",
+            0.0025f ),
+            new ParameterDefn<float>("VHACDplaneDownsampling", "granularity of search for best clipping plane",
+            4f ),
+            new ParameterDefn<float>("VHACDconvexHullDownsampling", "precision of hull gen process",
+            4f ),
+            new ParameterDefn<float>("VHACDalpha", "bias toward clipping along symmetry planes",
+            0.05f ),
+            new ParameterDefn<float>("VHACDbeta", "bias toward clipping along revolution axis",
+            0.05f ),
+            new ParameterDefn<float>("VHACDgamma", "max concavity when merging",
+            0.00125f ),
+            new ParameterDefn<float>("VHACDpca", "on/off normalizing mesh before decomp",
+            0f ),
+            new ParameterDefn<float>("VHACDmode", "0:voxel based, 1: tetrahedron based",
+            0f ),
+            new ParameterDefn<float>("VHACDmaxNumVerticesPerCH", "max triangles per convex hull",
+            64f ),
+            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)",
            (float)BSLinkset.LinksetImplementation.Compound ),
            new ParameterDefn<bool>("LinksetOffsetCenterOfMass", "If 'true', compute linkset center-of-mass and offset linkset position to account for same",
diff --git a/OpenSim/Region/Physics/BulletSPlugin/BSPhysObject.cs b/OpenSim/Region/Physics/BulletSPlugin/BSPhysObject.cs
index f89b376..90da7a6 100755
--- a/OpenSim/Region/Physics/BulletSPlugin/BSPhysObject.cs
+++ b/OpenSim/Region/Physics/BulletSPlugin/BSPhysObject.cs
@@ -80,28 +80,27 @@ public abstract class BSPhysObject : PhysicsActor
        Name = name;    // PhysicsActor also has the name of the object. Someday consolidate.
        TypeName = typeName;
-        // The collection of things that push me around
+        // Oddity if object is destroyed and recreated very quickly it could still have the old body.
-        PhysicalActors = new BSActorCollection(PhysScene);
+        if (!PhysBody.HasPhysicalBody)
+            PhysBody = new BulletBody(localID);
-        // Initialize variables kept in base.
+        // Clean out anything that might be in the physical actor list.
-        GravModifier = 1.0f;
+        // Again, a workaround for destroying and recreating an object very quickly.
-        Gravity = new OMV.Vector3(0f, 0f, BSParam.Gravity);
+        PhysicalActors.Dispose();
-        HoverActive = false;
-        // We don't have any physical representation yet.
-        PhysBody = new BulletBody(localID);
-        PhysShape = new BSShapeNull();
        UserSetCenterOfMassDisplacement = null;
        PrimAssetState = PrimAssetCondition.Unknown;
+        // Initialize variables kept in base.
+        // Beware that these cause taints to be queued whch can cause race conditions on startup.
+        GravModifier = 1.0f;
+        Gravity = new OMV.Vector3(0f, 0f, BSParam.Gravity);
+        HoverActive = false;
        // Default material type. Also sets Friction, Restitution and Density.
        SetMaterial((int)MaterialAttributes.Material.Wood);
-        CollisionCollection = new CollisionEventUpdate();
-        CollisionsLastReported = CollisionCollection;
-        CollisionsLastTick = new CollisionEventUpdate();
        CollisionsLastTickStep = -1;
        SubscribedEventsMs = 0;
@@ -136,6 +135,15 @@ public abstract class BSPhysObject : PhysicsActor
    // This mostly prevents property updates and collisions until the object is completely here.
    public bool IsInitialized { get; protected set; }
+    // Set to 'true' if an object (mesh/linkset/sculpty) is not completely constructed.
+    // This test is used to prevent some updates to the object when it only partially exists.
+    // There are several reasons and object might be incomplete:
+    //     Its underlying mesh/sculpty is an asset which must be fetched from the asset store
+    //     It is a linkset who is being added to or removed from
+    //     It is changing state (static to physical, for instance) which requires rebuilding
+    // This is a computed value based on the underlying physical object construction
+    abstract public bool IsIncomplete { get; }
    // Return the object mass without calculating it or having side effects
    public abstract float RawMass { get; }
    // Set the raw mass but also update physical mass properties (inertia, ...)
@@ -148,9 +156,9 @@ public abstract class BSPhysObject : PhysicsActor
    public OMV.Vector3 Inertia { get; set; }
    // Reference to the physical body (btCollisionObject) of this object
-    public BulletBody PhysBody;
+    public BulletBody PhysBody = new BulletBody(0);
    // Reference to the physical shape (btCollisionShape) of this object
-    public BSShape PhysShape;
+    public BSShape PhysShape = new BSShapeNull();
    // The physical representation of the prim might require an asset fetch.
    // The asset state is first 'Unknown' then 'Waiting' then either 'Failed' or 'Fetched'.
@@ -159,6 +167,11 @@ public abstract class BSPhysObject : PhysicsActor
        Unknown, Waiting, FailedAssetFetch, FailedMeshing, Fetched
    }
    public PrimAssetCondition PrimAssetState { get; set; }
+    public virtual bool AssetFailed()
+    {
+        return ( (this.PrimAssetState == PrimAssetCondition.FailedAssetFetch)
+              || (this.PrimAssetState == PrimAssetCondition.FailedMeshing) );
+    }
    // The objects base shape information. Null if not a prim type shape.
    public PrimitiveBaseShape BaseShape { get; protected set; }
@@ -223,7 +236,7 @@ public abstract class BSPhysObject : PhysicsActor
    public virtual OMV.Quaternion RawOrientation { get; set; }
    public abstract OMV.Quaternion ForceOrientation { get; set; }
-    public OMV.Vector3 RawVelocity { get; set; }
+    public virtual OMV.Vector3 RawVelocity { get; set; }
    public abstract OMV.Vector3 ForceVelocity { get; set; }
    public OMV.Vector3 RawForce { get; set; }
@@ -241,7 +254,12 @@ public abstract class BSPhysObject : PhysicsActor
    public virtual bool ForceBodyShapeRebuild(bool inTaintTime) { return false; }
-    public override bool PIDActive { set { MoveToTargetActive = value; } }
+    public override bool PIDActive 
+    {
+        get { return MoveToTargetActive; }
+        set { MoveToTargetActive = value; } 
+    }
    public override OMV.Vector3 PIDTarget { set { MoveToTargetTarget = value; } }
    public override float PIDTau { set { MoveToTargetTau = value; } }
@@ -290,11 +308,20 @@ public abstract class BSPhysObject : PhysicsActor
    // Note this is a displacement from the root's coordinates. Zero means use the root prim as center-of-mass.
    public OMV.Vector3? UserSetCenterOfMassDisplacement { get; set; }
-    public OMV.Vector3 LockedLinearAxis { get; set; } // zero means locked. one means free.
+    public OMV.Vector3 LockedLinearAxis;   // zero means locked. one means free.
-    public OMV.Vector3 LockedAngularAxis { get; set; } // zero means locked. one means free.
+    public OMV.Vector3 LockedAngularAxis;  // zero means locked. one means free.
    public const float FreeAxis = 1f;
+    public const float LockedAxis = 0f;
    public readonly OMV.Vector3 LockedAxisFree = new OMV.Vector3(FreeAxis, FreeAxis, FreeAxis);  // All axis are free
+    // If an axis is locked (flagged above) then the limits of that axis are specified here.
+    // Linear axis limits are relative to the object's starting coordinates.
+    // Angular limits are limited to -PI to +PI
+    public OMV.Vector3 LockedLinearAxisLow;
+    public OMV.Vector3 LockedLinearAxisHigh;
+    public OMV.Vector3 LockedAngularAxisLow;
+    public OMV.Vector3 LockedAngularAxisHigh;
    // Enable physical actions. Bullet will keep sleeping non-moving physical objects so
    //     they need waking up when parameters are changed.
    // Called in taint-time!!
@@ -416,12 +443,12 @@ public abstract class BSPhysObject : PhysicsActor
    }
    // The collisions that have been collected for the next collision reporting (throttled by subscription)
-    protected CollisionEventUpdate CollisionCollection;
+    protected CollisionEventUpdate CollisionCollection = new CollisionEventUpdate();
    // This is the collision collection last reported to the Simulator.
-    public CollisionEventUpdate CollisionsLastReported;
+    public CollisionEventUpdate CollisionsLastReported = new CollisionEventUpdate();
    // Remember the collisions recorded in the last tick for fancy collision checking
    //     (like a BSCharacter walking up stairs).
-    public CollisionEventUpdate CollisionsLastTick;
+    public CollisionEventUpdate CollisionsLastTick = new CollisionEventUpdate();
    private long CollisionsLastTickStep = -1;
    // The simulation step is telling this object about a collision.
@@ -462,8 +489,11 @@ public abstract class BSPhysObject : PhysicsActor
        // If someone has subscribed for collision events log the collision so it will be reported up
        if (SubscribedEvents()) {
-            CollisionCollection.AddCollider(collidingWith, new ContactPoint(contactPoint, contactNormal, pentrationDepth));
+            lock (PhysScene.CollisionLock)
-            DetailLog("{0},{1}.Collison.AddCollider,call,with={2},point={3},normal={4},depth={5},colliderMoving={6}",
+            {
+                CollisionCollection.AddCollider(collidingWith, new ContactPoint(contactPoint, contactNormal, pentrationDepth));
+            }
+            DetailLog("{0},{1}.Collision.AddCollider,call,with={2},point={3},normal={4},depth={5},colliderMoving={6}",
                            LocalID, TypeName, collidingWith, contactPoint, contactNormal, pentrationDepth, ColliderIsMoving);
            ret = true;
@@ -474,12 +504,14 @@ public abstract class BSPhysObject : PhysicsActor
    // Send the collected collisions into the simulator.
    // Called at taint time from within the Step() function thus no locking problems
    //      with CollisionCollection and ObjectsWithNoMoreCollisions.
+    // Called with BSScene.CollisionLock locked to protect the collision lists.
    // Return 'true' if there were some actual collisions passed up
    public virtual bool SendCollisions()
    {
        bool ret = true;
-        // If the 'no collision' call, force it to happen right now so quick collision_end
+        // If no collisions this call but there were collisions last call, force the collision
+        //     event to be happen right now so quick collision_end.
        bool force = (CollisionCollection.Count == 0 && CollisionsLastReported.Count != 0);
        // throttle the collisions to the number of milliseconds specified in the subscription
@@ -562,7 +594,7 @@ public abstract class BSPhysObject : PhysicsActor
    #region Per Simulation Step actions
-    public BSActorCollection PhysicalActors;
+    public BSActorCollection PhysicalActors = new BSActorCollection();
    // When an update to the physical properties happens, this event is fired to let
    //    different actors to modify the update before it is passed around
diff --git a/OpenSim/Region/Physics/BulletSPlugin/BSPrim.cs b/OpenSim/Region/Physics/BulletSPlugin/BSPrim.cs
index 15b7090..a00991f 100644
--- a/OpenSim/Region/Physics/BulletSPlugin/BSPrim.cs
+++ b/OpenSim/Region/Physics/BulletSPlugin/BSPrim.cs
@@ -1,4 +1,4 @@
-/*
+/*
 * Copyright (c) Contributors, http://opensimulator.org/
 * See CONTRIBUTORS.TXT for a full list of copyright holders.
 *
@@ -34,6 +34,7 @@ using OMV = OpenMetaverse;
 using OpenSim.Framework;
 using OpenSim.Region.Physics.Manager;
 using OpenSim.Region.Physics.ConvexDecompositionDotNet;
+using OpenSim.Region.OptionalModules.Scripting; // for ExtendedPhysics
 namespace OpenSim.Region.Physics.BulletSPlugin
 {
@@ -95,11 +96,9 @@ public class BSPrim : BSPhysObject
        _isPhysical = pisPhysical;
        _isVolumeDetect = false;
-        // Add a dynamic vehicle to our set of actors that can move this prim.
-        // PhysicalActors.Add(VehicleActorName, new BSDynamics(PhysScene, this, VehicleActorName));
        _mass = CalculateMass();
+        DetailLog("{0},BSPrim.constructor,pbs={1}", LocalID, BSScene.PrimitiveBaseShapeToString(pbs));
        // DetailLog("{0},BSPrim.constructor,call", LocalID);
        // do the actual object creation at taint time
        PhysScene.TaintedObject(LocalID, "BSPrim.create", delegate()
@@ -141,6 +140,18 @@ public class BSPrim : BSPhysObject
    public override bool Stopped {
        get { return false; }
    }
+    public override bool IsIncomplete {
+        get {
+            return ShapeRebuildScheduled;
+        }
+    }
+    // 'true' if this object's shape is in need of a rebuild and a rebuild has been queued.
+    // The prim is still available but its underlying shape will change soon.
+    // This is protected by a 'lock(this)'.
+    public bool ShapeRebuildScheduled { get; protected set; }
    public override OMV.Vector3 Size {
        get { return _size; }
        set {
@@ -155,17 +166,42 @@ public class BSPrim : BSPhysObject
    public override PrimitiveBaseShape Shape {
        set {
            BaseShape = value;
+            DetailLog("{0},BSPrim.changeShape,pbs={1}", LocalID, BSScene.PrimitiveBaseShapeToString(BaseShape));
            PrimAssetState = PrimAssetCondition.Unknown;
            ForceBodyShapeRebuild(false);
        }
    }
+    // Cause the body and shape of the prim to be rebuilt if necessary.
+    // If there are no changes required, this is quick and does not make changes to the prim.
+    // If rebuilding is necessary (like changing from static to physical), that will happen.
+    // The 'ShapeRebuildScheduled' tells any checker that the body/shape may change shortly.
+    // The return parameter is not used by anyone.
    public override bool ForceBodyShapeRebuild(bool inTaintTime)
    {
-        PhysScene.TaintedObject(inTaintTime, LocalID, "BSPrim.ForceBodyShapeRebuild", delegate()
+        if (inTaintTime)
        {
+            // If called in taint time, do the operation immediately
            _mass = CalculateMass();   // changing the shape changes the mass
            CreateGeomAndObject(true);
-        });
+        }
+        else
+        {
+            lock (this)
+            {
+                // If a rebuild is not already in the queue
+                if (!ShapeRebuildScheduled)
+                {
+                    // Remember that a rebuild is queued -- this is used to flag an incomplete object
+                    ShapeRebuildScheduled = true;
+                    PhysScene.TaintedObject(LocalID, "BSPrim.ForceBodyShapeRebuild", delegate()
+                    {
+                        _mass = CalculateMass();   // changing the shape changes the mass
+                        CreateGeomAndObject(true);
+                        ShapeRebuildScheduled = false;
+                    });
+                }
+            }
+        }
        return true;
    }
    public override bool Grabbed {
@@ -249,23 +285,21 @@ public class BSPrim : BSPhysObject
    {
        DetailLog("{0},BSPrim.LockAngularMotion,call,axis={1}", LocalID, axis);
-        // "1" means free, "0" means locked
+        ApplyAxisLimits(ExtendedPhysics.PHYS_AXIS_UNLOCK_ANGULAR, 0f, 0f);
-        OMV.Vector3 locking = LockedAxisFree;
+        if (axis.X != 1)
-        if (axis.X != 1) locking.X = 0f;
-        if (axis.Y != 1) locking.Y = 0f;
-        if (axis.Z != 1) locking.Z = 0f;
-        LockedAngularAxis = locking;
-        EnableActor(LockedAngularAxis != LockedAxisFree, LockedAxisActorName, delegate()
        {
-            return new BSActorLockAxis(PhysScene, this, LockedAxisActorName);
+            ApplyAxisLimits(ExtendedPhysics.PHYS_AXIS_LOCK_ANGULAR_X, 0f, 0f);
-        });
+        }
+        if (axis.Y != 1)
-        // Update parameters so the new actor's Refresh() action is called at the right time.
-        PhysScene.TaintedObject(LocalID, "BSPrim.LockAngularMotion", delegate()
        {
-            UpdatePhysicalParameters();
+            ApplyAxisLimits(ExtendedPhysics.PHYS_AXIS_LOCK_ANGULAR_Y, 0f, 0f);
-        });
+        }
+        if (axis.Z != 1)
+        {
+            ApplyAxisLimits(ExtendedPhysics.PHYS_AXIS_LOCK_ANGULAR_Z, 0f, 0f);
+        }
+        InitializeAxisActor();
        return;
    }
@@ -376,18 +410,19 @@ public class BSPrim : BSPhysObject
    {
        bool ret = false;
-        uint wayOutThere = Constants.RegionSize * Constants.RegionSize;
+        int wayOverThere = -1000;
+        int wayOutThere = 10000;
        // There have been instances of objects getting thrown way out of bounds and crashing
        //    the border crossing code.
-        if (   RawPosition.X < -Constants.RegionSize || RawPosition.X > wayOutThere
+        if (   RawPosition.X < wayOverThere || RawPosition.X > wayOutThere
-            || RawPosition.Y < -Constants.RegionSize || RawPosition.Y > wayOutThere
+            || RawPosition.Y < wayOverThere || RawPosition.X > wayOutThere
-            || RawPosition.Z < -Constants.RegionSize || RawPosition.Z > wayOutThere)
+            || RawPosition.Z < wayOverThere || RawPosition.X > wayOutThere)
        {
            RawPosition = new OMV.Vector3(10, 10, 50);
            ZeroMotion(inTaintTime);
            ret = true;
        }
-        if (RawVelocity.LengthSquared() > BSParam.MaxLinearVelocity)
+        if (RawVelocity.LengthSquared() > BSParam.MaxLinearVelocitySquared)
        {
            RawVelocity = Util.ClampV(RawVelocity, BSParam.MaxLinearVelocity);
            ret = true;
@@ -496,6 +531,12 @@ public class BSPrim : BSPhysObject
            {
                return new BSActorSetForce(PhysScene, this, SetForceActorName);
            });
+            // Call update so actor Refresh() is called to start things off
+            PhysScene.TaintedObject(LocalID, "BSPrim.setForce", delegate()
+            {
+                UpdatePhysicalParameters();
+            });
        }
    }
@@ -729,6 +770,12 @@ public class BSPrim : BSPhysObject
                return new BSActorSetTorque(PhysScene, this, SetTorqueActorName);
            });
            DetailLog("{0},BSPrim.SetTorque,call,torque={1}", LocalID, RawTorque);
+            // Call update so actor Refresh() is called to start things off
+            PhysScene.TaintedObject(LocalID, "BSPrim.setTorque", delegate()
+            {
+                UpdatePhysicalParameters();
+            });
        }
    }
    public override OMV.Vector3 Acceleration {
@@ -1086,13 +1133,27 @@ public class BSPrim : BSPhysObject
        }
    }
-    public override bool PIDActive {
+    public override bool PIDActive 
-        set {
+    {
-            base.MoveToTargetActive = value;
+        get
+        {
+            return MoveToTargetActive;
+        }
+        set 
+        {
+            MoveToTargetActive = value;
            EnableActor(MoveToTargetActive, MoveToTargetActorName, delegate()
            {
                return new BSActorMoveToTarget(PhysScene, this, MoveToTargetActorName);
            });
+            // Call update so actor Refresh() is called to start things off
+            PhysScene.TaintedObject(LocalID, "BSPrim.PIDActive", delegate()
+            {
+                UpdatePhysicalParameters();
+            });
        }
    }
@@ -1119,6 +1180,12 @@ public class BSPrim : BSPhysObject
            {
                return new BSActorHover(PhysScene, this, HoverActorName);
            });
+            // Call update so actor Refresh() is called to start things off
+            PhysScene.TaintedObject(LocalID, "BSPrim.PIDHoverActive", delegate()
+            {
+                UpdatePhysicalParameters();
+            });
        }
    }
@@ -1556,12 +1623,232 @@ public class BSPrim : BSPhysObject
        object ret = null;
        switch (pFunct)
        {
+            case ExtendedPhysics.PhysFunctAxisLockLimits:
+                ret = SetAxisLockLimitsExtension(pParams);
+                break;
            default:
                ret = base.Extension(pFunct, pParams);
                break;
        }
        return ret;
    }
+    private void InitializeAxisActor()
+    {
+        EnableActor(LockedAngularAxis != LockedAxisFree || LockedLinearAxis != LockedAxisFree,
+                                    LockedAxisActorName, delegate()
+        {
+            return new BSActorLockAxis(PhysScene, this, LockedAxisActorName);
+        });
+        // Update parameters so the new actor's Refresh() action is called at the right time.
+        PhysScene.TaintedObject(LocalID, "BSPrim.LockAxis", delegate()
+        {
+            UpdatePhysicalParameters();
+        });
+    }
+    // Passed an array of an array of parameters, set the axis locking.
+    // This expects an int (PHYS_AXIS_*) followed by none or two limit floats
+    //    followed by another int and floats, etc.
+    private object SetAxisLockLimitsExtension(object[] pParams)
+    {
+        DetailLog("{0} SetAxisLockLimitsExtension. parmlen={1}", LocalID, pParams.GetLength(0));
+        object ret = null;
+        try
+        {
+            if (pParams.GetLength(0) > 1)
+            {
+                int index = 2;
+                while (index < pParams.GetLength(0))
+                {
+                    var funct = pParams[index];
+                    DetailLog("{0} SetAxisLockLimitsExtension. op={1}, index={2}", LocalID, funct, index);
+                    if (funct is Int32 || funct is Int64)
+                    {
+                        switch ((int)funct)
+                        {
+                            // Those that take no parameters
+                            case ExtendedPhysics.PHYS_AXIS_LOCK_LINEAR:
+                            case ExtendedPhysics.PHYS_AXIS_LOCK_LINEAR_X:
+                            case ExtendedPhysics.PHYS_AXIS_LOCK_LINEAR_Y:
+                            case ExtendedPhysics.PHYS_AXIS_LOCK_LINEAR_Z:
+                            case ExtendedPhysics.PHYS_AXIS_LOCK_ANGULAR:
+                            case ExtendedPhysics.PHYS_AXIS_LOCK_ANGULAR_X:
+                            case ExtendedPhysics.PHYS_AXIS_LOCK_ANGULAR_Y:
+                            case ExtendedPhysics.PHYS_AXIS_LOCK_ANGULAR_Z:
+                            case ExtendedPhysics.PHYS_AXIS_UNLOCK_LINEAR:
+                            case ExtendedPhysics.PHYS_AXIS_UNLOCK_LINEAR_X:
+                            case ExtendedPhysics.PHYS_AXIS_UNLOCK_LINEAR_Y:
+                            case ExtendedPhysics.PHYS_AXIS_UNLOCK_LINEAR_Z:
+                            case ExtendedPhysics.PHYS_AXIS_UNLOCK_ANGULAR:
+                            case ExtendedPhysics.PHYS_AXIS_UNLOCK_ANGULAR_X:
+                            case ExtendedPhysics.PHYS_AXIS_UNLOCK_ANGULAR_Y:
+                            case ExtendedPhysics.PHYS_AXIS_UNLOCK_ANGULAR_Z:
+                            case ExtendedPhysics.PHYS_AXIS_UNLOCK:
+                                ApplyAxisLimits((int)funct, 0f, 0f);
+                                index += 1;
+                                break;
+                            // Those that take two parameters (the limits)
+                            case ExtendedPhysics.PHYS_AXIS_LIMIT_LINEAR_X:
+                            case ExtendedPhysics.PHYS_AXIS_LIMIT_LINEAR_Y:
+                            case ExtendedPhysics.PHYS_AXIS_LIMIT_LINEAR_Z:
+                            case ExtendedPhysics.PHYS_AXIS_LIMIT_ANGULAR_X:
+                            case ExtendedPhysics.PHYS_AXIS_LIMIT_ANGULAR_Y:
+                            case ExtendedPhysics.PHYS_AXIS_LIMIT_ANGULAR_Z:
+                                ApplyAxisLimits((int)funct, (float)pParams[index + 1], (float)pParams[index + 2]);
+                                index += 3;
+                                break;
+                            default:
+                                m_log.WarnFormat("{0} SetSxisLockLimitsExtension. Unknown op={1}", LogHeader, funct);
+                                index += 1;
+                                break;
+                        }
+                    }
+                }
+                InitializeAxisActor();
+                ret = (object)index;
+            }
+        }
+        catch (Exception e)
+        {
+            m_log.WarnFormat("{0} SetSxisLockLimitsExtension exception in object {1}: {2}", LogHeader, this.Name, e);
+            ret = null;
+        }
+        return ret;    // not implemented yet
+    }
+        // Set the locking parameters.
+        // If an axis is locked, the limits for the axis are set to zero,
+        // If the axis is being constrained, the high and low value are passed and set.
+        // When done here, LockedXXXAxis flags are set and LockedXXXAxixLow/High are set to the range.
+    protected void ApplyAxisLimits(int funct, float low, float high)
+    {
+        DetailLog("{0} ApplyAxisLimits. op={1}, low={2}, high={3}", LocalID, funct, low, high);
+        float linearMax = 23000f;
+        float angularMax = (float)Math.PI;
+        switch (funct)
+        {
+            case ExtendedPhysics.PHYS_AXIS_LOCK_LINEAR:
+                this.LockedLinearAxis = new OMV.Vector3(LockedAxis, LockedAxis, LockedAxis);
+                this.LockedLinearAxisLow = OMV.Vector3.Zero;
+                this.LockedLinearAxisHigh = OMV.Vector3.Zero;
+                break;
+            case ExtendedPhysics.PHYS_AXIS_LOCK_LINEAR_X:
+                this.LockedLinearAxis.X = LockedAxis;
+                this.LockedLinearAxisLow.X = 0f;
+                this.LockedLinearAxisHigh.X = 0f;
+                break;
+            case ExtendedPhysics.PHYS_AXIS_LIMIT_LINEAR_X:
+                this.LockedLinearAxis.X = LockedAxis;
+                this.LockedLinearAxisLow.X = Util.Clip(low, -linearMax, linearMax);
+                this.LockedLinearAxisHigh.X = Util.Clip(high, -linearMax, linearMax);
+                break;
+            case ExtendedPhysics.PHYS_AXIS_LOCK_LINEAR_Y:
+                this.LockedLinearAxis.Y = LockedAxis;
+                this.LockedLinearAxisLow.Y = 0f;
+                this.LockedLinearAxisHigh.Y = 0f;
+                break;
+            case ExtendedPhysics.PHYS_AXIS_LIMIT_LINEAR_Y:
+                this.LockedLinearAxis.Y = LockedAxis;
+                this.LockedLinearAxisLow.Y = Util.Clip(low, -linearMax, linearMax);
+                this.LockedLinearAxisHigh.Y = Util.Clip(high, -linearMax, linearMax);
+                break;
+            case ExtendedPhysics.PHYS_AXIS_LOCK_LINEAR_Z:
+                this.LockedLinearAxis.Z = LockedAxis;
+                this.LockedLinearAxisLow.Z = 0f;
+                this.LockedLinearAxisHigh.Z = 0f;
+                break;
+            case ExtendedPhysics.PHYS_AXIS_LIMIT_LINEAR_Z:
+                this.LockedLinearAxis.Z = LockedAxis;
+                this.LockedLinearAxisLow.Z = Util.Clip(low, -linearMax, linearMax);
+                this.LockedLinearAxisHigh.Z = Util.Clip(high, -linearMax, linearMax);
+                break;
+            case ExtendedPhysics.PHYS_AXIS_LOCK_ANGULAR:
+                this.LockedAngularAxis = new OMV.Vector3(LockedAxis, LockedAxis, LockedAxis);
+                this.LockedAngularAxisLow = OMV.Vector3.Zero;
+                this.LockedAngularAxisHigh = OMV.Vector3.Zero;
+                break;
+            case ExtendedPhysics.PHYS_AXIS_LOCK_ANGULAR_X:
+                this.LockedAngularAxis.X = LockedAxis;
+                this.LockedAngularAxisLow.X = 0;
+                this.LockedAngularAxisHigh.X = 0;
+                break;
+            case ExtendedPhysics.PHYS_AXIS_LIMIT_ANGULAR_X:
+                this.LockedAngularAxis.X = LockedAxis;
+                this.LockedAngularAxisLow.X = Util.Clip(low, -angularMax, angularMax);
+                this.LockedAngularAxisHigh.X = Util.Clip(high, -angularMax, angularMax);
+                break;
+            case ExtendedPhysics.PHYS_AXIS_LOCK_ANGULAR_Y:
+                this.LockedAngularAxis.Y = LockedAxis;
+                this.LockedAngularAxisLow.Y = 0;
+                this.LockedAngularAxisHigh.Y = 0;
+                break;
+            case ExtendedPhysics.PHYS_AXIS_LIMIT_ANGULAR_Y:
+                this.LockedAngularAxis.Y = LockedAxis;
+                this.LockedAngularAxisLow.Y = Util.Clip(low, -angularMax, angularMax);
+                this.LockedAngularAxisHigh.Y = Util.Clip(high, -angularMax, angularMax);
+                break;
+            case ExtendedPhysics.PHYS_AXIS_LOCK_ANGULAR_Z:
+                this.LockedAngularAxis.Z = LockedAxis;
+                this.LockedAngularAxisLow.Z = 0;
+                this.LockedAngularAxisHigh.Z = 0;
+                break;
+            case ExtendedPhysics.PHYS_AXIS_LIMIT_ANGULAR_Z:
+                this.LockedAngularAxis.Z = LockedAxis;
+                this.LockedAngularAxisLow.Z = Util.Clip(low, -angularMax, angularMax);
+                this.LockedAngularAxisHigh.Z = Util.Clip(high, -angularMax, angularMax);
+                break;
+            case ExtendedPhysics.PHYS_AXIS_UNLOCK_LINEAR:
+                this.LockedLinearAxis = LockedAxisFree;
+                this.LockedLinearAxisLow = new OMV.Vector3(-linearMax, -linearMax, -linearMax);
+                this.LockedLinearAxisHigh = new OMV.Vector3(linearMax, linearMax, linearMax);
+                break;
+            case ExtendedPhysics.PHYS_AXIS_UNLOCK_LINEAR_X:
+                this.LockedLinearAxis.X = FreeAxis;
+                this.LockedLinearAxisLow.X = -linearMax;
+                this.LockedLinearAxisHigh.X = linearMax;
+                break;
+            case ExtendedPhysics.PHYS_AXIS_UNLOCK_LINEAR_Y:
+                this.LockedLinearAxis.Y = FreeAxis;
+                this.LockedLinearAxisLow.Y = -linearMax;
+                this.LockedLinearAxisHigh.Y = linearMax;
+                break;
+            case ExtendedPhysics.PHYS_AXIS_UNLOCK_LINEAR_Z:
+                this.LockedLinearAxis.Z = FreeAxis;
+                this.LockedLinearAxisLow.Z = -linearMax;
+                this.LockedLinearAxisHigh.Z = linearMax;
+                break;
+            case ExtendedPhysics.PHYS_AXIS_UNLOCK_ANGULAR:
+                this.LockedAngularAxis = LockedAxisFree;
+                this.LockedAngularAxisLow = new OMV.Vector3(-angularMax, -angularMax, -angularMax);
+                this.LockedAngularAxisHigh = new OMV.Vector3(angularMax, angularMax, angularMax);
+                break;
+            case ExtendedPhysics.PHYS_AXIS_UNLOCK_ANGULAR_X:
+                this.LockedAngularAxis.X = FreeAxis;
+                this.LockedAngularAxisLow.X = -angularMax;
+                this.LockedAngularAxisHigh.X = angularMax;
+                break;
+            case ExtendedPhysics.PHYS_AXIS_UNLOCK_ANGULAR_Y:
+                this.LockedAngularAxis.Y = FreeAxis;
+                this.LockedAngularAxisLow.Y = -angularMax;
+                this.LockedAngularAxisHigh.Y = angularMax;
+                break;
+            case ExtendedPhysics.PHYS_AXIS_UNLOCK_ANGULAR_Z:
+                this.LockedAngularAxis.Z = FreeAxis;
+                this.LockedAngularAxisLow.Z = -angularMax;
+                this.LockedAngularAxisHigh.Z = angularMax;
+                break;
+            case ExtendedPhysics.PHYS_AXIS_UNLOCK:
+                ApplyAxisLimits(ExtendedPhysics.PHYS_AXIS_UNLOCK_LINEAR, 0f, 0f);
+                ApplyAxisLimits(ExtendedPhysics.PHYS_AXIS_UNLOCK_ANGULAR, 0f, 0f);
+                break;
+            default:
+                break;
+        }
+        return;
+    }
    #endregion  // Extension
    // The physics engine says that properties have updated. Update same and inform
diff --git a/OpenSim/Region/Physics/BulletSPlugin/BSPrimLinkable.cs b/OpenSim/Region/Physics/BulletSPlugin/BSPrimLinkable.cs
index 126b146..430d645 100755
--- a/OpenSim/Region/Physics/BulletSPlugin/BSPrimLinkable.cs
+++ b/OpenSim/Region/Physics/BulletSPlugin/BSPrimLinkable.cs
@@ -42,7 +42,9 @@ public class BSPrimLinkable : BSPrimDisplaced
    //    operations necessary for keeping the linkset created and, additionally, this
    //    calls the linkset implementation for its creation and management.
+#pragma warning disable 414
    private static readonly string LogHeader = "[BULLETS PRIMLINKABLE]";
+#pragma warning restore 414
    // This adds the overrides for link() and delink() so the prim is linkable.
diff --git a/OpenSim/Region/Physics/BulletSPlugin/BSScene.cs b/OpenSim/Region/Physics/BulletSPlugin/BSScene.cs
index b3dfa41..8a19944 100644
--- a/OpenSim/Region/Physics/BulletSPlugin/BSScene.cs
+++ b/OpenSim/Region/Physics/BulletSPlugin/BSScene.cs
@@ -32,6 +32,7 @@ using System.Runtime.InteropServices;
 using System.Text;
 using System.Threading;
 using OpenSim.Framework;
+using OpenSim.Framework.Monitoring;
 using OpenSim.Region.Framework;
 using OpenSim.Region.CoreModules;
 using Logging = OpenSim.Region.CoreModules.Framework.Statistics.Logging;
@@ -75,7 +76,8 @@ public sealed class BSScene : PhysicsScene, IPhysicsParameters
    // Keep track of all the avatars so we can send them a collision event
    //    every tick so OpenSim will update its animation.
-    private HashSet<BSPhysObject> m_avatars = new HashSet<BSPhysObject>();
+    private HashSet<BSPhysObject> AvatarsInScene = new HashSet<BSPhysObject>();
+    private Object AvatarsInSceneLock = new Object();
    // let my minuions use my logger
    public ILog Logger { get { return m_log; } }
@@ -88,7 +90,7 @@ public sealed class BSScene : PhysicsScene, IPhysicsParameters
    public BSConstraintCollection Constraints { get; private set; }
    // Simulation parameters
-    internal float m_physicsStepTime;   // if running independently, the interval simulated by default
+    //internal float m_physicsStepTime;   // if running independently, the interval simulated by default
    internal int m_maxSubSteps;
    internal float m_fixedTimeStep;
@@ -129,6 +131,11 @@ public sealed class BSScene : PhysicsScene, IPhysicsParameters
    internal int m_maxUpdatesPerFrame;
    internal EntityProperties[] m_updateArray;
+    /// <summary>
+    /// Used to control physics simulation timing if Bullet is running on its own thread.
+    /// </summary>
+    private ManualResetEvent m_updateWaitEvent;
    public const uint TERRAIN_ID = 0;       // OpenSim senses terrain with a localID of zero
    public const uint GROUNDPLANE_ID = 1;
    public const uint CHILDTERRAIN_ID = 2;  // Terrain allocated based on our mega-prim childre start here
@@ -208,8 +215,17 @@ public sealed class BSScene : PhysicsScene, IPhysicsParameters
        Name = EngineType + "/" + RegionName;
    }
+    // Old version of initialization that assumes legacy sized regions (256x256)
    public override void Initialise(IMesher meshmerizer, IConfigSource config)
    {
+        m_log.ErrorFormat("{0} WARNING WARNING WARNING! BulletSim initialized without region extent specification. Terrain will be messed up.");
+        Vector3 regionExtent = new Vector3( Constants.RegionSize, Constants.RegionSize, Constants.RegionSize);
+        Initialise(meshmerizer, config, regionExtent);
+        
+    }
+    public override void Initialise(IMesher meshmerizer, IConfigSource config, Vector3 regionExtent)
+    {
        mesher = meshmerizer;
        _taintOperations = new List<TaintCallbackEntry>();
        _postTaintOperations = new Dictionary<string, TaintCallbackEntry>();
@@ -226,6 +242,14 @@ public sealed class BSScene : PhysicsScene, IPhysicsParameters
        // Set default values for physics parameters plus any overrides from the ini file
        GetInitialParameterValues(config);
+        // Force some parameters to values depending on other configurations
+        // Only use heightmap terrain implementation if terrain larger than legacy size
+        if ((uint)regionExtent.X > Constants.RegionSize || (uint)regionExtent.Y > Constants.RegionSize)
+        {
+            m_log.WarnFormat("{0} Forcing terrain implementation to heightmap for large region", LogHeader);
+            BSParam.TerrainImplementation = (float)BSTerrainPhys.TerrainImplementation.Heightmap;
+        }
        // Get the connection to the physics engine (could be native or one of many DLLs)
        PE = SelectUnderlyingBulletEngine(BulletEngineName);
@@ -250,13 +274,13 @@ public sealed class BSScene : PhysicsScene, IPhysicsParameters
        //    a child in a mega-region.
        // Bullet actually doesn't care about the extents of the simulated
        //    area. It tracks active objects no matter where they are.
-        Vector3 worldExtent = new Vector3(Constants.RegionSize, Constants.RegionSize, Constants.RegionHeight);
+        Vector3 worldExtent = regionExtent;
        World = PE.Initialize(worldExtent, Params, m_maxCollisionsPerFrame, ref m_collisionArray, m_maxUpdatesPerFrame, ref m_updateArray);
        Constraints = new BSConstraintCollection(World);
-        TerrainManager = new BSTerrainManager(this);
+        TerrainManager = new BSTerrainManager(this, worldExtent);
        TerrainManager.CreateInitialGroundPlaneAndTerrain();
        // Put some informational messages into the log file.
@@ -269,9 +293,13 @@ public sealed class BSScene : PhysicsScene, IPhysicsParameters
        if (BSParam.UseSeparatePhysicsThread)
        {
            // The physics simulation should happen independently of the heartbeat loop
-            m_physicsThread = new Thread(BulletSPluginPhysicsThread);
+            m_physicsThread 
-            m_physicsThread.Name = BulletEngineName;
+                = WorkManager.StartThread(
-            m_physicsThread.Start();
+                    BulletSPluginPhysicsThread, 
+                    string.Format("{0} ({1})", BulletEngineName, RegionName), 
+                    ThreadPriority.Normal, 
+                    true, 
+                    true);
        }
    }
@@ -381,7 +409,7 @@ public sealed class BSScene : PhysicsScene, IPhysicsParameters
        if (ret == null)
        {
-            m_log.ErrorFormat("{0) COULD NOT SELECT BULLET ENGINE: '[BulletSim]PhysicsEngine' must be either 'BulletUnmanaged-*' or 'BulletXNA-*'", LogHeader);
+            m_log.ErrorFormat("{0} COULD NOT SELECT BULLET ENGINE: '[BulletSim]PhysicsEngine' must be either 'BulletUnmanaged-*' or 'BulletXNA-*'", LogHeader);
        }
        else
        {
@@ -398,11 +426,14 @@ public sealed class BSScene : PhysicsScene, IPhysicsParameters
        // make sure no stepping happens while we're deleting stuff
        m_initialized = false;
-        foreach (KeyValuePair<uint, BSPhysObject> kvp in PhysObjects)
+        lock (PhysObjects)
        {
-            kvp.Value.Destroy();
+            foreach (KeyValuePair<uint, BSPhysObject> kvp in PhysObjects)
+            {
+                kvp.Value.Destroy();
+            }
+            PhysObjects.Clear();
        }
-        PhysObjects.Clear();
        // Now that the prims are all cleaned up, there should be no constraints left
        if (Constraints != null)
@@ -434,27 +465,27 @@ public sealed class BSScene : PhysicsScene, IPhysicsParameters
    #region Prim and Avatar addition and removal
-    public override PhysicsActor AddAvatar(string avName, Vector3 position, Vector3 size, bool isFlying)
+    public override PhysicsActor AddAvatar(string avName, Vector3 position, Vector3 velocity, Vector3 size, bool isFlying)
    {
        m_log.ErrorFormat("{0}: CALL TO AddAvatar in BSScene. NOT IMPLEMENTED", LogHeader);
        return null;
    }
-    public override PhysicsActor AddAvatar(uint localID, string avName, Vector3 position, Vector3 size, bool isFlying)
+    public override PhysicsActor AddAvatar(uint localID, string avName, Vector3 position, Vector3 velocity, Vector3 size, bool isFlying)
    {
        // m_log.DebugFormat("{0}: AddAvatar: {1}", LogHeader, avName);
        if (!m_initialized) return null;
-        BSCharacter actor = new BSCharacter(localID, avName, this, position, size, isFlying);
+        BSCharacter actor = new BSCharacter(localID, avName, this, position, velocity, size, isFlying);
        lock (PhysObjects)
            PhysObjects.Add(localID, actor);
        // TODO: Remove kludge someday.
        // We must generate a collision for avatars whether they collide or not.
        // This is required by OpenSim to update avatar animations, etc.
-        lock (m_avatars)
+        lock (AvatarsInSceneLock)
-            m_avatars.Add(actor);
+            AvatarsInScene.Add(actor);
        return actor;
    }
@@ -473,8 +504,8 @@ public sealed class BSScene : PhysicsScene, IPhysicsParameters
                lock (PhysObjects)
                    PhysObjects.Remove(bsactor.LocalID);
                // Remove kludge someday
-                lock (m_avatars)
+                lock (AvatarsInSceneLock)
-                    m_avatars.Remove(bsactor);
+                    AvatarsInScene.Remove(bsactor);
            }
            catch (Exception e)
            {
@@ -622,15 +653,18 @@ public sealed class BSScene : PhysicsScene, IPhysicsParameters
        {
            if (collidersCount > 0)
            {
-                for (int ii = 0; ii < collidersCount; ii++)
+                lock (PhysObjects)
                {
-                    uint cA = m_collisionArray[ii].aID;
+                    for (int ii = 0; ii < collidersCount; ii++)
-                    uint cB = m_collisionArray[ii].bID;
+                    {
-                    Vector3 point = m_collisionArray[ii].point;
+                        uint cA = m_collisionArray[ii].aID;
-                    Vector3 normal = m_collisionArray[ii].normal;
+                        uint cB = m_collisionArray[ii].bID;
-                    float penetration = m_collisionArray[ii].penetration;
+                        Vector3 point = m_collisionArray[ii].point;
-                    SendCollision(cA, cB, point, normal, penetration);
+                        Vector3 normal = m_collisionArray[ii].normal;
-                    SendCollision(cB, cA, point, -normal, penetration);
+                        float penetration = m_collisionArray[ii].penetration;
+                        SendCollision(cA, cB, point, normal, penetration);
+                        SendCollision(cB, cA, point, -normal, penetration);
+                    }
                }
            }
        }
@@ -641,14 +675,17 @@ public sealed class BSScene : PhysicsScene, IPhysicsParameters
        {
            if (updatedEntityCount > 0)
            {
-                for (int ii = 0; ii < updatedEntityCount; ii++)
+                lock (PhysObjects)
                {
-                    EntityProperties entprop = m_updateArray[ii];
+                    for (int ii = 0; ii < updatedEntityCount; ii++)
-                    BSPhysObject pobj;
-                    if (PhysObjects.TryGetValue(entprop.ID, out pobj))
                    {
-                        if (pobj.IsInitialized)
+                        EntityProperties entprop = m_updateArray[ii];
-                            pobj.UpdateProperties(entprop);
+                        BSPhysObject pobj;
+                        if (PhysObjects.TryGetValue(entprop.ID, out pobj))
+                        {
+                            if (pobj.IsInitialized)
+                                pobj.UpdateProperties(entprop);
+                        }
                    }
                }
            }
@@ -682,7 +719,10 @@ public sealed class BSScene : PhysicsScene, IPhysicsParameters
    //    this is is under UpdateLock.
    public void PostUpdate(BSPhysObject updatee)
    {
-        ObjectsWithUpdates.Add(updatee);
+        lock (UpdateLock)
+        {
+            ObjectsWithUpdates.Add(updatee);
+        }
    }
    // The simulator thinks it is physics time so return all the collisions and position
@@ -710,9 +750,18 @@ public sealed class BSScene : PhysicsScene, IPhysicsParameters
            // The simulator expects collisions for avatars even if there are have been no collisions.
            //    The event updates avatar animations and stuff.
            // If you fix avatar animation updates, remove this overhead and let normal collision processing happen.
-            foreach (BSPhysObject bsp in m_avatars)
+            // Note that we get a copy of the list to search because SendCollision() can take a while.
-                if (!ObjectsWithCollisions.Contains(bsp))   // don't call avatars twice
+            HashSet<BSPhysObject> tempAvatarsInScene;
-                    bsp.SendCollisions();
+            lock (AvatarsInSceneLock)
+            {
+                tempAvatarsInScene = new HashSet<BSPhysObject>(AvatarsInScene);
+            }
+            foreach (BSPhysObject actor in tempAvatarsInScene)
+            {
+                if (!ObjectsWithCollisions.Contains(actor))   // don't call avatars twice
+                    actor.SendCollisions();
+            }
+            tempAvatarsInScene = null;
            // Objects that are done colliding are removed from the ObjectsWithCollisions list.
            // Not done above because it is inside an iteration of ObjectWithCollisions.
@@ -762,6 +811,7 @@ public sealed class BSScene : PhysicsScene, IPhysicsParameters
        }
        BSPhysObject collider;
+        // NOTE that PhysObjects was locked before the call to SendCollision().
        if (!PhysObjects.TryGetValue(localID, out collider))
        {
            // If the object that is colliding cannot be found, just ignore the collision.
@@ -780,7 +830,10 @@ public sealed class BSScene : PhysicsScene, IPhysicsParameters
            if (collider.Collide(collidingWith, collidee, collidePoint, collideNormal, penetration))
            {
                // If a collision was 'good', remember to send it to the simulator
-                ObjectsWithCollisions.Add(collider);
+                lock (CollisionLock)
+                {
+                    ObjectsWithCollisions.Add(collider);
+                }
            }
        }
@@ -789,18 +842,25 @@ public sealed class BSScene : PhysicsScene, IPhysicsParameters
    public void BulletSPluginPhysicsThread()
    {
+        Thread.CurrentThread.Priority = ThreadPriority.Highest;
+        m_updateWaitEvent = new ManualResetEvent(false);
        while (m_initialized)
        {
            int beginSimulationRealtimeMS = Util.EnvironmentTickCount();
-            DoPhysicsStep(BSParam.PhysicsTimeStep);
+            if (BSParam.Active)
+                DoPhysicsStep(BSParam.PhysicsTimeStep);
            int simulationRealtimeMS = Util.EnvironmentTickCountSubtract(beginSimulationRealtimeMS);
            int simulationTimeVsRealtimeDifferenceMS = ((int)(BSParam.PhysicsTimeStep*1000f)) - simulationRealtimeMS;
            if (simulationTimeVsRealtimeDifferenceMS > 0)
            {
                // The simulation of the time interval took less than realtime.
-                // Do a sleep for the rest of realtime.
+                // Do a wait for the rest of realtime.
-                Thread.Sleep(simulationTimeVsRealtimeDifferenceMS);
+                 m_updateWaitEvent.WaitOne(simulationTimeVsRealtimeDifferenceMS);
+                //Thread.Sleep(simulationTimeVsRealtimeDifferenceMS);
            }
            else
            {
@@ -809,7 +869,11 @@ public sealed class BSScene : PhysicsScene, IPhysicsParameters
                // TODO.
                DetailLog("{0},BulletSPluginPhysicsThread,longerThanRealtime={1}", BSScene.DetailLogZero, simulationTimeVsRealtimeDifferenceMS);
            }
+            Watchdog.UpdateThread();
        }
+        Watchdog.RemoveThread();
    }
    #endregion // Simulation
@@ -882,6 +946,75 @@ public sealed class BSScene : PhysicsScene, IPhysicsParameters
    }
    #endregion // Extensions
+    public static string PrimitiveBaseShapeToString(PrimitiveBaseShape pbs)
+    {
+        float pathShearX = pbs.PathShearX < 128 ? (float)pbs.PathShearX * 0.01f : (float)(pbs.PathShearX - 256) * 0.01f;
+        float pathShearY = pbs.PathShearY < 128 ? (float)pbs.PathShearY * 0.01f : (float)(pbs.PathShearY - 256) * 0.01f;
+        float pathBegin = (float)pbs.PathBegin * 2.0e-5f;
+        float pathEnd = 1.0f - (float)pbs.PathEnd * 2.0e-5f;
+        float pathScaleX = (float)(200 - pbs.PathScaleX) * 0.01f;
+        float pathScaleY = (float)(200 - pbs.PathScaleY) * 0.01f;
+        float pathTaperX = pbs.PathTaperX * 0.01f;
+        float pathTaperY = pbs.PathTaperY * 0.01f;
+        float profileBegin = (float)pbs.ProfileBegin * 2.0e-5f;
+        float profileEnd = 1.0f - (float)pbs.ProfileEnd * 2.0e-5f;
+        float profileHollow = (float)pbs.ProfileHollow * 2.0e-5f;
+        if (profileHollow > 0.95f)
+            profileHollow = 0.95f;
+        StringBuilder buff = new StringBuilder();
+        buff.Append("shape=");
+        buff.Append(((ProfileShape)pbs.ProfileShape).ToString());
+        buff.Append(",");
+        buff.Append("hollow=");
+        buff.Append(((HollowShape)pbs.HollowShape).ToString());
+        buff.Append(",");
+        buff.Append("pathCurve=");
+        buff.Append(((Extrusion)pbs.PathCurve).ToString());
+        buff.Append(",");
+        buff.Append("profCurve=");
+        buff.Append(((Extrusion)pbs.ProfileCurve).ToString());
+        buff.Append(",");
+        buff.Append("profHollow=");
+        buff.Append(profileHollow.ToString());
+        buff.Append(",");
+        buff.Append("pathBegEnd=");
+        buff.Append(pathBegin.ToString());
+        buff.Append("/");
+        buff.Append(pathEnd.ToString());
+        buff.Append(",");
+        buff.Append("profileBegEnd=");
+        buff.Append(profileBegin.ToString());
+        buff.Append("/");
+        buff.Append(profileEnd.ToString());
+        buff.Append(",");
+        buff.Append("scaleXY=");
+        buff.Append(pathScaleX.ToString());
+        buff.Append("/");
+        buff.Append(pathScaleY.ToString());
+        buff.Append(",");
+        buff.Append("shearXY=");
+        buff.Append(pathShearX.ToString());
+        buff.Append("/");
+        buff.Append(pathShearY.ToString());
+        buff.Append(",");
+        buff.Append("taperXY=");
+        buff.Append(pbs.PathTaperX.ToString());
+        buff.Append("/");
+        buff.Append(pbs.PathTaperY.ToString());
+        buff.Append(",");
+        buff.Append("skew=");
+        buff.Append(pbs.PathSkew.ToString());
+        buff.Append(",");
+        buff.Append("twist/Beg=");
+        buff.Append(pbs.PathTwist.ToString());
+        buff.Append("/");
+        buff.Append(pbs.PathTwistBegin.ToString());
+        return buff.ToString();
+    }
    #region Taints
    // The simulation execution order is:
    // Simulate()
diff --git a/OpenSim/Region/Physics/BulletSPlugin/BSShapeCollection.cs b/OpenSim/Region/Physics/BulletSPlugin/BSShapeCollection.cs
index 32bbc8f..d1de844 100755
--- a/OpenSim/Region/Physics/BulletSPlugin/BSShapeCollection.cs
+++ b/OpenSim/Region/Physics/BulletSPlugin/BSShapeCollection.cs
@@ -36,7 +36,9 @@ namespace OpenSim.Region.Physics.BulletSPlugin
 {
 public sealed class BSShapeCollection : IDisposable
 {
+#pragma warning disable 414
    private static string LogHeader = "[BULLETSIM SHAPE COLLECTION]";
+#pragma warning restore 414
    private BSScene m_physicsScene { get; set; }
@@ -124,6 +126,10 @@ public sealed class BSShapeCollection : IDisposable
    // Info in prim.BSShape is updated to the new shape.
    // Returns 'true' if the geometry was rebuilt.
    // Called at taint-time!
+    public const int AvatarShapeCapsule = 0;
+    public const int AvatarShapeCube = 1;
+    public const int AvatarShapeOvoid = 2;
+    public const int AvatarShapeMesh = 3;
    private bool CreateGeom(bool forceRebuild, BSPhysObject prim, PhysicalDestructionCallback shapeCallback)
    {
        bool ret = false;
@@ -137,10 +143,32 @@ public sealed class BSShapeCollection : IDisposable
        if (theChar != null)
        {
            DereferenceExistingShape(prim, shapeCallback);
-            prim.PhysShape = BSShapeNative.GetReference(m_physicsScene, prim,
+            switch (BSParam.AvatarShape)
+            {
+                case AvatarShapeCapsule:
+                    prim.PhysShape = BSShapeNative.GetReference(m_physicsScene, prim,
                                            BSPhysicsShapeType.SHAPE_CAPSULE, FixedShapeKey.KEY_CAPSULE);
-            ret = true;
+                    ret = true;
-            haveShape = true;
+                    haveShape = true;
+                    break;
+                case AvatarShapeCube:
+                    prim.PhysShape = BSShapeNative.GetReference(m_physicsScene, prim,
+                                            BSPhysicsShapeType.SHAPE_BOX, FixedShapeKey.KEY_CAPSULE);
+                    ret = true;
+                    haveShape = true;
+                    break;
+                case AvatarShapeOvoid:
+                    // Saddly, Bullet doesn't scale spheres so this doesn't work as an avatar shape
+                    prim.PhysShape = BSShapeNative.GetReference(m_physicsScene, prim,
+                                            BSPhysicsShapeType.SHAPE_SPHERE, FixedShapeKey.KEY_CAPSULE);
+                    ret = true;
+                    haveShape = true;
+                    break;
+                case AvatarShapeMesh:
+                    break;
+                default:
+                    break;
+            }
        }
        // If the prim attributes are simple, this could be a simple Bullet native shape
diff --git a/OpenSim/Region/Physics/BulletSPlugin/BSShapes.cs b/OpenSim/Region/Physics/BulletSPlugin/BSShapes.cs
index fe5ff6c..03a9ddc 100755
--- a/OpenSim/Region/Physics/BulletSPlugin/BSShapes.cs
+++ b/OpenSim/Region/Physics/BulletSPlugin/BSShapes.cs
@@ -38,6 +38,76 @@ using OMV = OpenMetaverse;
 namespace OpenSim.Region.Physics.BulletSPlugin
 {
+// Information class that holds stats for the shape. Which values mean
+//     something depends on the type of shape.
+// This information is used for debugging and stats and is not used
+//     for operational things.
+public class ShapeInfoInfo
+{
+    public int Vertices { get; set; }
+    private int m_hullCount;
+    private int[] m_verticesPerHull;
+    public ShapeInfoInfo()
+    {
+        Vertices = 0;
+        m_hullCount = 0;
+        m_verticesPerHull = null;
+    }
+    public int HullCount
+    {
+        set
+        {
+            m_hullCount = value;
+            m_verticesPerHull = new int[m_hullCount];
+            Array.Clear(m_verticesPerHull, 0, m_hullCount);
+        }
+        get { return m_hullCount; }
+    }
+    public void SetVerticesPerHull(int hullNum, int vertices)
+    {
+        if (m_verticesPerHull != null && hullNum < m_verticesPerHull.Length)
+        {
+            m_verticesPerHull[hullNum] = vertices;
+        }
+    }
+    public int GetVerticesPerHull(int hullNum)
+    {
+        if (m_verticesPerHull != null && hullNum < m_verticesPerHull.Length)
+        {
+            return m_verticesPerHull[hullNum];
+        }
+        return 0;
+    }
+    public override string ToString()
+    {
+        StringBuilder buff = new StringBuilder();
+        // buff.Append("ShapeInfo=<");
+        buff.Append("<");
+        if (Vertices > 0)
+        {
+            buff.Append("verts=");
+            buff.Append(Vertices.ToString());
+        }
+        if (Vertices > 0 && HullCount > 0) buff.Append(",");
+        if (HullCount > 0)
+        {
+            buff.Append("nHulls=");
+            buff.Append(HullCount.ToString());
+            buff.Append(",");
+            buff.Append("hullVerts=");
+            for (int ii = 0; ii < HullCount; ii++)
+            {
+                if (ii != 0) buff.Append(",");
+                buff.Append(GetVerticesPerHull(ii).ToString());
+            }
+        }
+        buff.Append(">");
+        return buff.ToString();
+    }
+}
 public abstract class BSShape
 {
    private static string LogHeader = "[BULLETSIM SHAPE]";
@@ -45,18 +115,21 @@ public abstract class BSShape
    public int referenceCount { get; set; }
    public DateTime lastReferenced { get; set; }
    public BulletShape physShapeInfo { get; set; }
+    public ShapeInfoInfo shapeInfo { get; private set; }
    public BSShape()
    {
        referenceCount = 1;
        lastReferenced = DateTime.Now;
        physShapeInfo = new BulletShape();
+        shapeInfo = new ShapeInfoInfo();
    }
    public BSShape(BulletShape pShape)
    {
        referenceCount = 1;
        lastReferenced = DateTime.Now;
        physShapeInfo = pShape;
+        shapeInfo = new ShapeInfoInfo();
    }
    // Get another reference to this shape.
@@ -177,8 +250,7 @@ public abstract class BSShape
        {
            // If this mesh has an underlying asset and we have not failed getting it before, fetch the asset
            if (prim.BaseShape.SculptEntry
-                && prim.PrimAssetState != BSPhysObject.PrimAssetCondition.FailedAssetFetch
+                && !prim.AssetFailed()
-                && prim.PrimAssetState != BSPhysObject.PrimAssetCondition.FailedMeshing
                && prim.PrimAssetState != BSPhysObject.PrimAssetCondition.Waiting
                && prim.BaseShape.SculptTexture != OMV.UUID.Zero
                )
@@ -189,50 +261,46 @@ public abstract class BSShape
                prim.PrimAssetState = BSPhysObject.PrimAssetCondition.Waiting;
                BSPhysObject xprim = prim;
-                Util.FireAndForget(delegate
+                RequestAssetDelegate assetProvider = physicsScene.RequestAssetMethod;
+                if (assetProvider != null)
+                {
+                    BSPhysObject yprim = xprim; // probably not necessary, but, just in case.
+                    assetProvider(yprim.BaseShape.SculptTexture, delegate(AssetBase asset)
                    {
-                        // physicsScene.DetailLog("{0},BSShape.VerifyMeshCreated,inFireAndForget", xprim.LocalID);
+                        // physicsScene.DetailLog("{0},BSShape.VerifyMeshCreated,assetProviderCallback", xprim.LocalID);
-                        RequestAssetDelegate assetProvider = physicsScene.RequestAssetMethod;
+                        bool assetFound = false;
-                        if (assetProvider != null)
+                        string mismatchIDs = String.Empty;  // DEBUG DEBUG
+                        if (asset != null && yprim.BaseShape.SculptEntry)
                        {
-                            BSPhysObject yprim = xprim; // probably not necessary, but, just in case.
+                            if (yprim.BaseShape.SculptTexture.ToString() == asset.ID)
-                            assetProvider(yprim.BaseShape.SculptTexture, delegate(AssetBase asset)
                            {
-                                // physicsScene.DetailLog("{0},BSShape.VerifyMeshCreated,assetProviderCallback", xprim.LocalID);
+                                yprim.BaseShape.SculptData = asset.Data;
-                                bool assetFound = false;
+                                // This will cause the prim to see that the filler shape is not the right
-                                string mismatchIDs = String.Empty;  // DEBUG DEBUG
+                                //    one and try again to build the object.
-                                if (asset != null && yprim.BaseShape.SculptEntry)
+                                // No race condition with the normal shape setting since the rebuild is at taint time.
-                                {
+                                yprim.PrimAssetState = BSPhysObject.PrimAssetCondition.Fetched;
-                                    if (yprim.BaseShape.SculptTexture.ToString() == asset.ID)
+                                yprim.ForceBodyShapeRebuild(false /* inTaintTime */);
-                                    {
+                                assetFound = true;
-                                        yprim.BaseShape.SculptData = asset.Data;
+                            }
-                                        // This will cause the prim to see that the filler shape is not the right
+                            else
-                                        //    one and try again to build the object.
+                            {
-                                        // No race condition with the normal shape setting since the rebuild is at taint time.
+                                mismatchIDs = yprim.BaseShape.SculptTexture.ToString() + "/" + asset.ID;
-                                        yprim.PrimAssetState = BSPhysObject.PrimAssetCondition.Fetched;
+                            }
-                                        yprim.ForceBodyShapeRebuild(false /* inTaintTime */);
-                                        assetFound = true;
-                                    }
-                                    else
-                                    {
-                                        mismatchIDs = yprim.BaseShape.SculptTexture.ToString() + "/" + asset.ID;
-                                    }
-                                }
-                                if (!assetFound)
-                                {
-                                    yprim.PrimAssetState = BSPhysObject.PrimAssetCondition.FailedAssetFetch;
-                                }
-                                physicsScene.DetailLog("{0},BSShape.VerifyMeshCreated,fetchAssetCallback,found={1},isSculpt={2},ids={3}",
-                                            yprim.LocalID, assetFound, yprim.BaseShape.SculptEntry, mismatchIDs );
-                            });
                        }
-                        else
+                        if (!assetFound)
                        {
-                            xprim.PrimAssetState = BSPhysObject.PrimAssetCondition.FailedAssetFetch;
+                            yprim.PrimAssetState = BSPhysObject.PrimAssetCondition.FailedAssetFetch;
-                            physicsScene.Logger.ErrorFormat("{0} Physical object requires asset but no asset provider. Name={1}",
-                                                        LogHeader, physicsScene.Name);
                        }
+                        physicsScene.DetailLog("{0},BSShape.VerifyMeshCreated,fetchAssetCallback,found={1},isSculpt={2},ids={3}",
+                                    yprim.LocalID, assetFound, yprim.BaseShape.SculptEntry, mismatchIDs );
                    });
+                }
+                else
+                {
+                    xprim.PrimAssetState = BSPhysObject.PrimAssetCondition.FailedAssetFetch;
+                    physicsScene.Logger.ErrorFormat("{0} Physical object requires asset but no asset provider. Name={1}",
+                                                LogHeader, physicsScene.Name);
+                }
            }
            else
            {
@@ -288,6 +356,9 @@ public class BSShapeNull : BSShape
 }
 // ============================================================================================================
+// BSShapeNative is a wrapper for a Bullet 'native' shape -- cube and sphere.
+// They are odd in that they don't allocate meshes but are computated/procedural.
+// This means allocation and freeing is different than meshes.
 public class BSShapeNative : BSShape
 {
    private static string LogHeader = "[BULLETSIM SHAPE NATIVE]";
@@ -366,6 +437,7 @@ public class BSShapeNative : BSShape
 }
 // ============================================================================================================
+// BSShapeMesh is a simple mesh.
 public class BSShapeMesh : BSShape
 {
    private static string LogHeader = "[BULLETSIM SHAPE MESH]";
@@ -395,9 +467,7 @@ public class BSShapeMesh : BSShape
                // Check to see if mesh was created (might require an asset).
                newShape = VerifyMeshCreated(physicsScene, newShape, prim);
-                if (!newShape.isNativeShape
+                if (!newShape.isNativeShape || prim.AssetFailed() )
-                            || prim.PrimAssetState == BSPhysObject.PrimAssetCondition.FailedMeshing
-                            || prim.PrimAssetState == BSPhysObject.PrimAssetCondition.FailedAssetFetch)
                {
                    // If a mesh was what was created, remember the built shape for later sharing.
                    // Also note that if meshing failed we put it in the mesh list as there is nothing else to do about the mesh.
@@ -464,7 +534,11 @@ public class BSShapeMesh : BSShape
                                            PrimitiveBaseShape pbs, OMV.Vector3 size, float lod)
    {
        return BSShapeMesh.CreatePhysicalMeshShape(physicsScene, prim, newMeshKey, pbs, size, lod,
-                            (w, iC, i, vC, v) => physicsScene.PE.CreateMeshShape(w, iC, i, vC, v) );
+                            (w, iC, i, vC, v) =>
+                            {
+                                shapeInfo.Vertices = vC;
+                                return physicsScene.PE.CreateMeshShape(w, iC, i, vC, v);
+                            });
    }
    // Code that uses the mesher to create the index/vertices info for a trimesh shape.
@@ -554,11 +628,18 @@ public class BSShapeMesh : BSShape
 }
 // ============================================================================================================
+// BSShapeHull is a physical shape representation htat is made up of many convex hulls.
+// The convex hulls are either supplied with the asset or are approximated by one of the
+//     convex hull creation routines (in OpenSim or in Bullet).
 public class BSShapeHull : BSShape
 {
+#pragma warning disable 414
    private static string LogHeader = "[BULLETSIM SHAPE HULL]";
+#pragma warning restore 414
    public static Dictionary<System.UInt64, BSShapeHull> Hulls = new Dictionary<System.UInt64, BSShapeHull>();
    public BSShapeHull(BulletShape pShape) : base(pShape)
    {
    }
@@ -583,9 +664,7 @@ public class BSShapeHull : BSShape
                // Check to see if hull was created (might require an asset).
                newShape = VerifyMeshCreated(physicsScene, newShape, prim);
-                if (!newShape.isNativeShape
+                if (!newShape.isNativeShape || prim.AssetFailed())
-                            || prim.PrimAssetState == BSPhysObject.PrimAssetCondition.FailedMeshing
-                            || prim.PrimAssetState == BSPhysObject.PrimAssetCondition.FailedAssetFetch)
                {
                    // If a mesh was what was created, remember the built shape for later sharing.
                    Hulls.Add(newHullKey, retHull);
@@ -623,6 +702,7 @@ public class BSShapeHull : BSShape
            // TODO: schedule aging and destruction of unused meshes.
        }
    }
    List<ConvexResult> m_hulls;
    private BulletShape CreatePhysicalHull(BSScene physicsScene, BSPhysObject prim, System.UInt64 newHullKey,
                                            PrimitiveBaseShape pbs, OMV.Vector3 size, float lod)
@@ -655,6 +735,7 @@ public class BSShapeHull : BSShape
        if (allHulls != null && BSParam.ShouldUseAssetHulls)
        {
            int hullCount = allHulls.Count;
+            shapeInfo.HullCount = hullCount;
            int totalVertices = 1;      // include one for the count of the hulls
            // Using the structure described for HACD hulls, create the memory sturcture
            //     to pass the hull data to the creater.
@@ -667,6 +748,7 @@ public class BSShapeHull : BSShape
            convHulls[0] = (float)hullCount;
            int jj = 1;
+            int hullIndex = 0;
            foreach (List<OMV.Vector3> hullVerts in allHulls)
            {
                convHulls[jj + 0] = hullVerts.Count;
@@ -681,6 +763,8 @@ public class BSShapeHull : BSShape
                    convHulls[jj + 2] = oneVert.Z;
                    jj += 3;
                }
+                shapeInfo.SetVerticesPerHull(hullIndex, hullVerts.Count);
+                hullIndex++;
            }
            // create the hull data structure in Bullet
@@ -700,7 +784,7 @@ public class BSShapeHull : BSShape
            if (meshShape.physShapeInfo.HasPhysicalShape)
            {
-                HACDParams parms;
+                HACDParams parms = new HACDParams();
                parms.maxVerticesPerHull = BSParam.BHullMaxVerticesPerHull;
                parms.minClusters = BSParam.BHullMinClusters;
                parms.compacityWeight = BSParam.BHullCompacityWeight;
@@ -710,12 +794,17 @@ public class BSShapeHull : BSShape
                parms.addNeighboursDistPoints = BSParam.NumericBool(BSParam.BHullAddNeighboursDistPoints);
                parms.addFacesPoints = BSParam.NumericBool(BSParam.BHullAddFacesPoints);
                parms.shouldAdjustCollisionMargin = BSParam.NumericBool(BSParam.BHullShouldAdjustCollisionMargin);
+                parms.whichHACD = 0;    // Use the HACD routine that comes with Bullet
                physicsScene.DetailLog("{0},BSShapeHull.CreatePhysicalHull,hullFromMesh,beforeCall", prim.LocalID, newShape.HasPhysicalShape);
                newShape = physicsScene.PE.BuildHullShapeFromMesh(physicsScene.World, meshShape.physShapeInfo, parms);
                physicsScene.DetailLog("{0},BSShapeHull.CreatePhysicalHull,hullFromMesh,shape={1}", prim.LocalID, newShape);
                // Now done with the mesh shape.
+                shapeInfo.HullCount = 1;
+                BSShapeMesh maybeMesh = meshShape as BSShapeMesh;
+                if (maybeMesh != null)
+                    shapeInfo.SetVerticesPerHull(0, maybeMesh.shapeInfo.Vertices);
                meshShape.Dereference(physicsScene);
            }
            physicsScene.DetailLog("{0},BSShapeHull.CreatePhysicalHull,bulletHACD,exit,hasBody={1}", prim.LocalID, newShape.HasPhysicalShape);
@@ -865,6 +954,8 @@ public class BSShapeHull : BSShape
 }
 // ============================================================================================================
+// BSShapeCompound is a wrapper for the Bullet compound shape which is built from multiple, separate
+//    meshes. Used by BulletSim for complex shapes like linksets.
 public class BSShapeCompound : BSShape
 {
    private static string LogHeader = "[BULLETSIM SHAPE COMPOUND]";
@@ -993,6 +1084,11 @@ public class BSShapeCompound : BSShape
                                BSShapeNative nativeShape = new BSShapeNative(pShape);
                                nativeShape.Dereference(physicsScene);
                            }
+                            else
+                            {
+                                physicsScene.Logger.WarnFormat("{0} DereferenceAnonCollisionShape. Did not find shape. {1}",
+                                    LogHeader, pShape);
+                            }
                        }
                    }
                }
@@ -1002,9 +1098,15 @@ public class BSShapeCompound : BSShape
 }
 // ============================================================================================================
+// BSShapeConvexHull is a wrapper for a Bullet single convex hull. A BSShapeHull contains multiple convex
+//     hull shapes. This is used for simple prims that are convex and thus can be made into a simple
+//     collision shape (a single hull). More complex physical shapes will be BSShapeHull's.
 public class BSShapeConvexHull : BSShape
 {
+#pragma warning disable 414
    private static string LogHeader = "[BULLETSIM SHAPE CONVEX HULL]";
+#pragma warning restore 414
    public static Dictionary<System.UInt64, BSShapeConvexHull> ConvexHulls = new Dictionary<System.UInt64, BSShapeConvexHull>();
    public BSShapeConvexHull(BulletShape pShape) : base(pShape)
@@ -1098,9 +1200,15 @@ public class BSShapeConvexHull : BSShape
    }
 }
 // ============================================================================================================
+// BSShapeGImpact is a wrapper for the Bullet GImpact shape which is a collision mesh shape that
+//     can handle concave as well as convex shapes. Much slower computationally but creates smoother
+//     shapes than multiple convex hull approximations.
 public class BSShapeGImpact : BSShape
 {
+#pragma warning disable 414
    private static string LogHeader = "[BULLETSIM SHAPE GIMPACT]";
+#pragma warning restore 414
    public static Dictionary<System.UInt64, BSShapeGImpact> GImpacts = new Dictionary<System.UInt64, BSShapeGImpact>();
    public BSShapeGImpact(BulletShape pShape) : base(pShape)
@@ -1130,9 +1238,7 @@ public class BSShapeGImpact : BSShape
                // Check to see if mesh was created (might require an asset).
                newShape = VerifyMeshCreated(physicsScene, newShape, prim);
                newShape.shapeKey = newMeshKey;
-                if (!newShape.isNativeShape 
+                if (!newShape.isNativeShape || prim.AssetFailed())
-                            || prim.PrimAssetState == BSPhysObject.PrimAssetCondition.FailedMeshing
-                            || prim.PrimAssetState == BSPhysObject.PrimAssetCondition.FailedAssetFetch)
                {
                    // If a mesh was what was created, remember the built shape for later sharing.
                    // Also note that if meshing failed we put it in the mesh list as there is nothing
@@ -1150,7 +1256,11 @@ public class BSShapeGImpact : BSShape
                                            PrimitiveBaseShape pbs, OMV.Vector3 size, float lod)
    {
        return BSShapeMesh.CreatePhysicalMeshShape(physicsScene, prim, newMeshKey, pbs, size, lod,
-                            (w, iC, i, vC, v) => physicsScene.PE.CreateGImpactShape(w, iC, i, vC, v) );
+                            (w, iC, i, vC, v) =>
+                            {
+                                shapeInfo.Vertices = vC;
+                                return physicsScene.PE.CreateGImpactShape(w, iC, i, vC, v);
+                            });
    }
    public override BSShape GetReference(BSScene pPhysicsScene, BSPhysObject pPrim)
@@ -1205,10 +1315,15 @@ public class BSShapeGImpact : BSShape
 }
 // ============================================================================================================
+// BSShapeAvatar is a specialized mesh shape for avatars.
 public class BSShapeAvatar : BSShape
 {
+#pragma warning disable 414
    private static string LogHeader = "[BULLETSIM SHAPE AVATAR]";
-    public BSShapeAvatar() : base()
+#pragma warning restore 414
+    public BSShapeAvatar()
+        : base()
    {
    }
    public static BSShape GetReference(BSPhysObject prim)
diff --git a/OpenSim/Region/Physics/BulletSPlugin/BSTerrainHeightmap.cs b/OpenSim/Region/Physics/BulletSPlugin/BSTerrainHeightmap.cs
index 8888d6d..d70b2fb 100755
--- a/OpenSim/Region/Physics/BulletSPlugin/BSTerrainHeightmap.cs
+++ b/OpenSim/Region/Physics/BulletSPlugin/BSTerrainHeightmap.cs
@@ -58,7 +58,7 @@ public sealed class BSTerrainHeightmap : BSTerrainPhys
        {
            initialMap[ii] = BSTerrainManager.HEIGHT_INITIALIZATION;
        }
-        m_mapInfo = new BulletHMapInfo(id, initialMap);
+        m_mapInfo = new BulletHMapInfo(id, initialMap, regionSize.X, regionSize.Y);
        m_mapInfo.minCoords = minTerrainCoords;
        m_mapInfo.maxCoords = maxTerrainCoords;
        m_mapInfo.terrainRegionBase = TerrainBase;
@@ -72,7 +72,7 @@ public sealed class BSTerrainHeightmap : BSTerrainPhys
                                                    Vector3 minCoords, Vector3 maxCoords)
        : base(physicsScene, regionBase, id)
    {
-        m_mapInfo = new BulletHMapInfo(id, initialMap);
+        m_mapInfo = new BulletHMapInfo(id, initialMap, maxCoords.X - minCoords.X, maxCoords.Y - minCoords.Y);
        m_mapInfo.minCoords = minCoords;
        m_mapInfo.maxCoords = maxCoords;
        m_mapInfo.minZ = minCoords.Z;
diff --git a/OpenSim/Region/Physics/BulletSPlugin/BSTerrainManager.cs b/OpenSim/Region/Physics/BulletSPlugin/BSTerrainManager.cs
index 441d2d3..50f917a 100755
--- a/OpenSim/Region/Physics/BulletSPlugin/BSTerrainManager.cs
+++ b/OpenSim/Region/Physics/BulletSPlugin/BSTerrainManager.cs
@@ -1,4 +1,4 @@
-/*
+/*
 * Copyright (c) Contributors, http://opensimulator.org/
 * See CONTRIBUTORS.TXT for a full list of copyright holders.
 *
@@ -111,9 +111,11 @@ public sealed class BSTerrainManager : IDisposable
    private Vector3 m_worldMax;
    private PhysicsScene MegaRegionParentPhysicsScene { get; set; }
-    public BSTerrainManager(BSScene physicsScene)
+    public BSTerrainManager(BSScene physicsScene, Vector3 regionSize)
    {
        m_physicsScene = physicsScene;
+        DefaultRegionSize = regionSize;
        m_terrains = new Dictionary<Vector3,BSTerrainPhys>();
        // Assume one region of default size
@@ -135,8 +137,9 @@ public sealed class BSTerrainManager : IDisposable
        DetailLog("{0},BSTerrainManager.CreateInitialGroundPlaneAndTerrain,region={1}", BSScene.DetailLogZero, m_physicsScene.RegionName);
        // The ground plane is here to catch things that are trying to drop to negative infinity
        BulletShape groundPlaneShape = m_physicsScene.PE.CreateGroundPlaneShape(BSScene.GROUNDPLANE_ID, 1f, BSParam.TerrainCollisionMargin);
+        Vector3 groundPlaneAltitude = new Vector3(0f, 0f, BSParam.TerrainGroundPlane);
        m_groundPlane = m_physicsScene.PE.CreateBodyWithDefaultMotionState(groundPlaneShape,
-                                        BSScene.GROUNDPLANE_ID, Vector3.Zero, Quaternion.Identity);
+                                        BSScene.GROUNDPLANE_ID, groundPlaneAltitude, Quaternion.Identity);
        // Everything collides with the ground plane.
        m_groundPlane.collisionType = CollisionType.Groundplane;
@@ -237,9 +240,6 @@ public sealed class BSTerrainManager : IDisposable
    // Called during taint-time.
    private void UpdateTerrain(uint id, float[] heightMap, Vector3 minCoords, Vector3 maxCoords)
    {
-        DetailLog("{0},BSTerrainManager.UpdateTerrain,call,id={1},minC={2},maxC={3}",
-                            BSScene.DetailLogZero, id, minCoords, maxCoords);
        // Find high and low points of passed heightmap.
        // The min and max passed in is usually the area objects can be in (maximum
        //     object height, for instance). The terrain wants the bounding box for the
@@ -259,6 +259,9 @@ public sealed class BSTerrainManager : IDisposable
        minCoords.Z = minZ;
        maxCoords.Z = maxZ;
+        DetailLog("{0},BSTerrainManager.UpdateTerrain,call,id={1},minC={2},maxC={3}",
+                            BSScene.DetailLogZero, id, minCoords, maxCoords);
        Vector3 terrainRegionBase = new Vector3(minCoords.X, minCoords.Y, 0f);
        lock (m_terrains)
@@ -267,8 +270,8 @@ public sealed class BSTerrainManager : IDisposable
            if (m_terrains.TryGetValue(terrainRegionBase, out terrainPhys))
            {
                // There is already a terrain in this spot. Free the old and build the new.
-                DetailLog("{0},BSTErrainManager.UpdateTerrain:UpdateExisting,call,id={1},base={2},minC={3},maxC={4}",
+                DetailLog("{0},BSTerrainManager.UpdateTerrain:UpdateExisting,call,id={1},base={2},minC={3},maxC={4}",
-                                BSScene.DetailLogZero, id, terrainRegionBase, minCoords, minCoords);
+                                BSScene.DetailLogZero, id, terrainRegionBase, minCoords, maxCoords);
                // Remove old terrain from the collection
                m_terrains.Remove(terrainRegionBase);
diff --git a/OpenSim/Region/Physics/BulletSPlugin/BulletSimData.cs b/OpenSim/Region/Physics/BulletSPlugin/BulletSimData.cs
index 971ff9f..5932461 100755
--- a/OpenSim/Region/Physics/BulletSPlugin/BulletSimData.cs
+++ b/OpenSim/Region/Physics/BulletSPlugin/BulletSimData.cs
@@ -165,14 +165,15 @@ public class BulletConstraint
 //      than making copies.
 public class BulletHMapInfo
 {
-    public BulletHMapInfo(uint id, float[] hm) {
+    public BulletHMapInfo(uint id, float[] hm, float pSizeX, float pSizeY) {
        ID = id;
        heightMap = hm;
        terrainRegionBase = OMV.Vector3.Zero;
        minCoords = new OMV.Vector3(100f, 100f, 25f);
        maxCoords = new OMV.Vector3(101f, 101f, 26f);
        minZ = maxZ = 0f;
-        sizeX = sizeY = 256f;
+        sizeX = pSizeX;
+        sizeY = pSizeY;
    }
    public uint ID;
    public float[] heightMap;
@@ -189,6 +190,7 @@ public class BulletHMapInfo
 public enum CollisionType
 {
    Avatar,
+    PhantomToOthersAvatar, // An avatar that it phantom to other avatars but not to anything else
    Groundplane,
    Terrain,
    Static,
@@ -230,7 +232,12 @@ public static Dictionary<CollisionType, CollisionTypeFilterGroup> CollisionTypeM
    { CollisionType.Avatar,
                new CollisionTypeFilterGroup(CollisionType.Avatar,
                                (uint)CollisionFilterGroups.BCharacterGroup,
-                                (uint)CollisionFilterGroups.BAllGroup)
+                                (uint)(CollisionFilterGroups.BAllGroup))
+    },
+    { CollisionType.PhantomToOthersAvatar,
+        new CollisionTypeFilterGroup(CollisionType.PhantomToOthersAvatar,
+                                     (uint)CollisionFilterGroups.BCharacterGroup,
+                                     (uint)(CollisionFilterGroups.BAllGroup & ~CollisionFilterGroups.BCharacterGroup))
    },
    { CollisionType.Groundplane,
                new CollisionTypeFilterGroup(CollisionType.Groundplane,
diff --git a/OpenSim/Region/Physics/BulletSPlugin/Properties/AssemblyInfo.cs b/OpenSim/Region/Physics/BulletSPlugin/Properties/AssemblyInfo.cs
index d069178..4f90eee 100644
--- a/OpenSim/Region/Physics/BulletSPlugin/Properties/AssemblyInfo.cs
+++ b/OpenSim/Region/Physics/BulletSPlugin/Properties/AssemblyInfo.cs
@@ -29,5 +29,5 @@ using System.Runtime.InteropServices;
 //      Build Number
 //      Revision
 //
-[assembly: AssemblyVersion("0.8.0.*")]
+[assembly: AssemblyVersion("0.8.2.*")]
diff --git a/OpenSim/Region/Physics/BulletSPlugin/Tests/BulletSimTestsUtil.cs b/OpenSim/Region/Physics/BulletSPlugin/Tests/BulletSimTestsUtil.cs
index 28207a4..775bca2 100755
--- a/OpenSim/Region/Physics/BulletSPlugin/Tests/BulletSimTestsUtil.cs
+++ b/OpenSim/Region/Physics/BulletSPlugin/Tests/BulletSimTestsUtil.cs
@@ -28,15 +28,16 @@
 using System;
 using System.IO;
 using System.Collections.Generic;
-using System.Linq;
 using System.Text;
 using Nini.Config;
 using OpenSim.Framework;
-using OpenSim.Region.Physics.BulletSPlugin;
+using OpenSim.Region.Physics.Manager;
 using OpenSim.Region.Physics.Meshing;
+using OpenMetaverse;
 namespace OpenSim.Region.Physics.BulletSPlugin.Tests
 {
 // Utility functions for building up and tearing down the sample physics environments
@@ -77,17 +78,21 @@ public static class BulletSimTestsUtil
            bulletSimConfig.Set("VehicleLoggingEnabled","True");
        }
-        BSPlugin bsPlugin = new BSPlugin();
+        PhysicsPluginManager physicsPluginManager;
+        physicsPluginManager = new PhysicsPluginManager();
+        physicsPluginManager.LoadPluginsFromAssemblies("Physics");
+        Vector3 regionExtent = new Vector3(Constants.RegionSize, Constants.RegionSize, Constants.RegionHeight);
+       
+        PhysicsScene pScene = physicsPluginManager.GetPhysicsScene(
+                        "BulletSim", "Meshmerizer", openSimINI, "BSTestRegion", regionExtent);
-        BSScene bsScene = (BSScene)bsPlugin.GetScene("BSTestRegion");
+        BSScene bsScene = pScene as BSScene;
        // Since the asset requestor is not initialized, any mesh or sculptie will be a cube.
        // In the future, add a fake asset fetcher to get meshes and sculpts.
        // bsScene.RequestAssetMethod = ???;
-        Meshing.Meshmerizer mesher = new Meshmerizer(openSimINI);
-        bsScene.Initialise(mesher, openSimINI);
        return bsScene;
    }
diff --git a/OpenSim/Region/Physics/BulletSPlugin/Tests/HullCreation.cs b/OpenSim/Region/Physics/BulletSPlugin/Tests/HullCreation.cs
new file mode 100644
index 0000000..5a5de11
--- /dev/null
+++ b/OpenSim/Region/Physics/BulletSPlugin/Tests/HullCreation.cs
@@ -0,0 +1,205 @@
+/*
+ * 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.Physics.BulletSPlugin;
+using OpenSim.Region.Physics.Manager;
+using OpenSim.Tests.Common;
+using OpenMetaverse;
+namespace OpenSim.Region.Physics.BulletSPlugin.Tests
+{
+[TestFixture]
+public class HullCreation : 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; }
+    Vector3 ObjectInitPosition;
+    [TestFixtureSetUp]
+    public void Init()
+    {
+    }
+    [TestFixtureTearDown]
+    public void TearDown()
+    {
+        if (PhysicsScene != null)
+        {
+            // The Dispose() will also free any physical objects in the scene
+            PhysicsScene.Dispose();
+            PhysicsScene = null;
+        }
+    }
+    [TestCase(7, 2, 5f, 5f, 32, 0f)]    /* default hull parameters */
+    public void GeomHullConvexDecomp( int maxDepthSplit,
+                                        int maxDepthSplitForSimpleShapes,
+                                        float concavityThresholdPercent,
+                                        float volumeConservationThresholdPercent,
+                                        int maxVertices,
+                                        float maxSkinWidth)
+    {
+        // Setup the physics engine to use the C# version of convex decomp
+        Dictionary<string, string> engineParams = new Dictionary<string, string>();
+        engineParams.Add("MeshSculptedPrim", "true"); // ShouldMeshSculptedPrim
+        engineParams.Add("ForceSimplePrimMeshing", "false"); // ShouldForceSimplePrimMeshing
+        engineParams.Add("UseHullsForPhysicalObjects", "true"); // ShouldUseHullsForPhysicalObjects
+        engineParams.Add("ShouldRemoveZeroWidthTriangles", "true");
+        engineParams.Add("ShouldUseBulletHACD", "false");
+        engineParams.Add("ShouldUseSingleConvexHullForPrims", "true");
+        engineParams.Add("ShouldUseGImpactShapeForPrims", "false");
+        engineParams.Add("ShouldUseAssetHulls", "true");
+        engineParams.Add("CSHullMaxDepthSplit", maxDepthSplit.ToString());
+        engineParams.Add("CSHullMaxDepthSplitForSimpleShapes", maxDepthSplitForSimpleShapes.ToString());
+        engineParams.Add("CSHullConcavityThresholdPercent", concavityThresholdPercent.ToString());
+        engineParams.Add("CSHullVolumeConservationThresholdPercent", volumeConservationThresholdPercent.ToString());
+        engineParams.Add("CSHullMaxVertices", maxVertices.ToString());
+        engineParams.Add("CSHullMaxSkinWidth", maxSkinWidth.ToString());
+        PhysicsScene = BulletSimTestsUtil.CreateBasicPhysicsEngine(engineParams);
+        PrimitiveBaseShape pbs;
+        Vector3 pos;
+        Vector3 size;
+        Quaternion rot;
+        bool isPhys;
+        // Cylinder
+        pbs = PrimitiveBaseShape.CreateCylinder();
+        pos = new Vector3(100.0f, 100.0f, 0f);
+        pos.Z = PhysicsScene.TerrainManager.GetTerrainHeightAtXYZ(pos) + 10f;
+        ObjectInitPosition = pos;
+        size = new Vector3(2f, 2f, 2f);
+        pbs.Scale = size;
+        rot = Quaternion.Identity;
+        isPhys = true;
+        uint cylinderLocalID = 123;
+        PhysicsScene.AddPrimShape("testCylinder", pbs, pos, size, rot, isPhys, cylinderLocalID);
+        BSPrim primTypeCylinder = (BSPrim)PhysicsScene.PhysObjects[cylinderLocalID];
+        // Hollow Cylinder
+        pbs = PrimitiveBaseShape.CreateCylinder();
+        pbs.ProfileHollow = (ushort)(0.70f * 50000);
+        pos = new Vector3(110.0f, 110.0f, 0f);
+        pos.Z = PhysicsScene.TerrainManager.GetTerrainHeightAtXYZ(pos) + 10f;
+        ObjectInitPosition = pos;
+        size = new Vector3(2f, 2f, 2f);
+        pbs.Scale = size;
+        rot = Quaternion.Identity;
+        isPhys = true;
+        uint hollowCylinderLocalID = 124;
+        PhysicsScene.AddPrimShape("testHollowCylinder", pbs, pos, size, rot, isPhys, hollowCylinderLocalID);
+        BSPrim primTypeHollowCylinder = (BSPrim)PhysicsScene.PhysObjects[hollowCylinderLocalID];
+        // Torus
+        // ProfileCurve = Circle, PathCurve = Curve1
+        pbs = PrimitiveBaseShape.CreateSphere();
+        pbs.ProfileShape = (byte)ProfileShape.Circle;
+        pbs.PathCurve = (byte)Extrusion.Curve1;
+        pbs.PathScaleX = 100;   // default hollow info as set in the viewer
+        pbs.PathScaleY = (int)(.25f / 0.01f) + 200;
+        pos = new Vector3(120.0f, 120.0f, 0f);
+        pos.Z = PhysicsScene.TerrainManager.GetTerrainHeightAtXYZ(pos) + 10f;
+        ObjectInitPosition = pos;
+        size = new Vector3(2f, 4f, 4f);
+        pbs.Scale = size;
+        rot = Quaternion.Identity;
+        isPhys = true;
+        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();
+        // Check out the created hull shapes and report their characteristics
+        ReportShapeGeom(primTypeCylinder);
+        ReportShapeGeom(primTypeHollowCylinder);
+        ReportShapeGeom(primTypeTorus);
+    }
+    [TestCase]
+    public void GeomHullBulletHACD()
+    {
+        // Cylinder
+        // Hollow Cylinder
+        // Torus
+    }
+    private void ReportShapeGeom(BSPrim prim)
+    {
+        if (prim != null)
+        {
+            if (prim.PhysShape.HasPhysicalShape)
+            {
+                BSShape physShape = prim.PhysShape;
+                string shapeType = physShape.GetType().ToString();
+                switch (shapeType)
+                {
+                    case "OpenSim.Region.Physics.BulletSPlugin.BSShapeNative":
+                        BSShapeNative nShape = physShape as BSShapeNative;
+                        prim.PhysScene.DetailLog("{0}, type={1}", prim.Name, shapeType);
+                        break;
+                    case "OpenSim.Region.Physics.BulletSPlugin.BSShapeMesh":
+                        BSShapeMesh mShape = physShape as BSShapeMesh;
+                        prim.PhysScene.DetailLog("{0}, mesh, shapeInfo={1}", prim.Name, mShape.shapeInfo);
+                        break;
+                    case "OpenSim.Region.Physics.BulletSPlugin.BSShapeHull":
+                        // BSShapeHull hShape = physShape as BSShapeHull;
+                        // prim.PhysScene.DetailLog("{0}, hull, shapeInfo={1}", prim.Name, hShape.shapeInfo);
+                        break;
+                    case "OpenSim.Region.Physics.BulletSPlugin.BSShapeConvexHull":
+                        BSShapeConvexHull chShape = physShape as BSShapeConvexHull;
+                        prim.PhysScene.DetailLog("{0}, convexHull, shapeInfo={1}", prim.Name, chShape.shapeInfo);
+                        break;
+                    case "OpenSim.Region.Physics.BulletSPlugin.BSShapeCompound":
+                        BSShapeCompound cShape = physShape as BSShapeCompound;
+                        prim.PhysScene.DetailLog("{0}, type={1}", prim.Name, shapeType);
+                        break;
+                    default:
+                        prim.PhysScene.DetailLog("{0}, type={1}", prim.Name, shapeType);
+                        break;
+                }
+            }
+        }
+    }
+}
+}
+\ No newline at end of file
diff --git a/OpenSim/Region/Physics/ConvexDecompositionDotNet/Properties/AssemblyInfo.cs b/OpenSim/Region/Physics/ConvexDecompositionDotNet/Properties/AssemblyInfo.cs
index b8cf624..c5867b2 100644
--- a/OpenSim/Region/Physics/ConvexDecompositionDotNet/Properties/AssemblyInfo.cs
+++ b/OpenSim/Region/Physics/ConvexDecompositionDotNet/Properties/AssemblyInfo.cs
@@ -32,5 +32,5 @@ using System.Runtime.InteropServices;
 // You can specify all the values or you can default the Build and Revision Numbers 
 // by using the '*' as shown below:
 // [assembly: AssemblyVersion("1.0.*")]
-[assembly: AssemblyVersion("0.8.0.*")]
+[assembly: AssemblyVersion("0.8.2.*")]
diff --git a/OpenSim/Region/Physics/Manager/AssemblyInfo.cs b/OpenSim/Region/Physics/Manager/AssemblyInfo.cs
index 10e850e..33f60e4 100644
--- a/OpenSim/Region/Physics/Manager/AssemblyInfo.cs
+++ b/OpenSim/Region/Physics/Manager/AssemblyInfo.cs
@@ -55,4 +55,4 @@ using System.Runtime.InteropServices;
 // You can specify all values by your own or you can build default build and revision
 // numbers with the '*' character (the default):
-[assembly : AssemblyVersion("0.8.0.*")]
+[assembly : AssemblyVersion("0.8.2.*")]
diff --git a/OpenSim/Region/Physics/Manager/NullPhysicsScene.cs b/OpenSim/Region/Physics/Manager/NullPhysicsScene.cs
index 1ccf46d..b52f1f6 100644
--- a/OpenSim/Region/Physics/Manager/NullPhysicsScene.cs
+++ b/OpenSim/Region/Physics/Manager/NullPhysicsScene.cs
@@ -45,7 +45,8 @@ namespace OpenSim.Region.Physics.Manager
            // Does nothing right now
        }
-        public override PhysicsActor AddAvatar(string avName, Vector3 position, Vector3 size, bool isFlying)
+        public override PhysicsActor AddAvatar(
+            string avName, Vector3 position, Vector3 velocity, Vector3 size, bool isFlying)
        {
            m_log.InfoFormat("[PHYSICS]: NullPhysicsScene : AddAvatar({0})", position);
            return PhysicsActor.Null;
diff --git a/OpenSim/Region/Physics/Manager/PhysicsActor.cs b/OpenSim/Region/Physics/Manager/PhysicsActor.cs
index 44bfd42..60f6480 100644
--- a/OpenSim/Region/Physics/Manager/PhysicsActor.cs
+++ b/OpenSim/Region/Physics/Manager/PhysicsActor.cs
@@ -386,7 +386,7 @@ namespace OpenSim.Region.Physics.Manager
        // Used for MoveTo
        public abstract Vector3 PIDTarget { set; }
-        public abstract bool  PIDActive { set;}
+        public abstract bool PIDActive { get; set; }
        public abstract float PIDTau { set; }
        // Used for llSetHoverHeight and maybe vehicle height
@@ -611,7 +611,13 @@ namespace OpenSim.Region.Physics.Manager
        }
        public override Vector3 PIDTarget { set { return; } }
-        public override bool PIDActive { set { return; } }
+        public override bool PIDActive 
+        {
+            get { return false; }
+            set { return; } 
+        }
        public override float PIDTau { set { return; } }
        public override float PIDHoverHeight { set { return; } }
diff --git a/OpenSim/Region/Physics/Manager/PhysicsPluginManager.cs b/OpenSim/Region/Physics/Manager/PhysicsPluginManager.cs
index d14edfd..ddbe80b 100644
--- a/OpenSim/Region/Physics/Manager/PhysicsPluginManager.cs
+++ b/OpenSim/Region/Physics/Manager/PhysicsPluginManager.cs
@@ -180,7 +180,7 @@ namespace OpenSim.Region.Physics.Manager
                        {
                            if (!pluginType.IsAbstract)
                            {
-                                Type physTypeInterface = pluginType.GetInterface("IPhysicsPlugin", true);
+                                Type physTypeInterface = pluginType.GetInterface("IPhysicsPlugin");
                                if (physTypeInterface != null)
                                {
@@ -194,7 +194,7 @@ namespace OpenSim.Region.Physics.Manager
                                    }
                                }
-                                Type meshTypeInterface = pluginType.GetInterface("IMeshingPlugin", true);
+                                Type meshTypeInterface = pluginType.GetInterface("IMeshingPlugin");
                                if (meshTypeInterface != null)
                                {
diff --git a/OpenSim/Region/Physics/Manager/PhysicsScene.cs b/OpenSim/Region/Physics/Manager/PhysicsScene.cs
index 4f4ff07..96ef0a6 100644
--- a/OpenSim/Region/Physics/Manager/PhysicsScene.cs
+++ b/OpenSim/Region/Physics/Manager/PhysicsScene.cs
@@ -148,26 +148,38 @@ namespace OpenSim.Region.Physics.Manager
        /// </summary>
        /// <param name="avName"></param>
        /// <param name="position"></param>
+        /// <param name="velocity"></param>
        /// <param name="size"></param>
        /// <param name="isFlying"></param>
        /// <returns></returns>
+<<<<<<< HEAD
+        public abstract PhysicsActor AddAvatar(
+            string avName, Vector3 position, Vector3 velocity, Vector3 size, bool isFlying);
+=======
        public virtual PhysicsActor AddAvatar(string avName, Vector3 position, Vector3 size, bool isFlying)
        {
            return null;
        }
+>>>>>>> avn/ubitvar
        /// <summary>
        /// Add an avatar
        /// </summary>
        /// <param name="localID"></param>
        /// <param name="avName"></param>
        /// <param name="position"></param>
+        /// <param name="velocity"></param>
        /// <param name="size"></param>
        /// <param name="isFlying"></param>
        /// <returns></returns>
-        public virtual PhysicsActor AddAvatar(uint localID, string avName, Vector3 position, Vector3 size, bool isFlying)
+        public virtual PhysicsActor AddAvatar(
+            uint localID, string avName, Vector3 position, Vector3 velocity, Vector3 size, bool isFlying)
        {
-            PhysicsActor ret = AddAvatar(avName, position, size, isFlying);
+            PhysicsActor ret = AddAvatar(avName, position, velocity, size, isFlying);
-            if (ret != null) ret.LocalID = localID;
+            if (ret != null) 
+                ret.LocalID = localID;
            return ret;
        }
diff --git a/OpenSim/Region/Physics/Meshing/Meshmerizer.cs b/OpenSim/Region/Physics/Meshing/Meshmerizer.cs
index d67d4d2..ef6482a 100644
--- a/OpenSim/Region/Physics/Meshing/Meshmerizer.cs
+++ b/OpenSim/Region/Physics/Meshing/Meshmerizer.cs
@@ -84,7 +84,8 @@ namespace OpenSim.Region.Physics.Meshing
        private List<List<Vector3>> mConvexHulls = null;
        private List<Vector3> mBoundingHull = null;
-        private Dictionary<ulong, Mesh> m_uniqueMeshes = new Dictionary<ulong, Mesh>();
+        // Mesh cache. Static so it can be shared across instances of this class
+        private static Dictionary<ulong, Mesh> m_uniqueMeshes = new Dictionary<ulong, Mesh>();
        public Meshmerizer(IConfigSource config)
        {
@@ -937,8 +938,11 @@ namespace OpenSim.Region.Physics.Meshing
            if (shouldCache)
            {
                key = primShape.GetMeshKey(size, lod);
-                if (m_uniqueMeshes.TryGetValue(key, out mesh))
+                lock (m_uniqueMeshes)
-                    return mesh;
+                {
+                    if (m_uniqueMeshes.TryGetValue(key, out mesh))
+                        return mesh;
+                }
            }
            if (size.X < 0.01f) size.X = 0.01f;
@@ -964,7 +968,10 @@ namespace OpenSim.Region.Physics.Meshing
                if (shouldCache)
                {
-                    m_uniqueMeshes.Add(key, mesh);
+                    lock (m_uniqueMeshes)
+                    {
+                        m_uniqueMeshes.Add(key, mesh);
+                    }
                }
            }
diff --git a/OpenSim/Region/Physics/Meshing/Properties/AssemblyInfo.cs b/OpenSim/Region/Physics/Meshing/Properties/AssemblyInfo.cs
index 8542753..ec968c0 100644
--- a/OpenSim/Region/Physics/Meshing/Properties/AssemblyInfo.cs
+++ b/OpenSim/Region/Physics/Meshing/Properties/AssemblyInfo.cs
@@ -29,5 +29,5 @@ using System.Runtime.InteropServices;
 //      Build Number
 //      Revision
 //
-[assembly: AssemblyVersion("0.8.0.*")]
+[assembly: AssemblyVersion("0.8.2.*")]
diff --git a/OpenSim/Region/Physics/OdePlugin/ODECharacter.cs b/OpenSim/Region/Physics/OdePlugin/ODECharacter.cs
index 43bef3c..9203169 100644
--- a/OpenSim/Region/Physics/OdePlugin/ODECharacter.cs
+++ b/OpenSim/Region/Physics/OdePlugin/ODECharacter.cs
@@ -1251,8 +1251,12 @@ namespace OpenSim.Region.Physics.OdePlugin
        public override Vector3 PIDTarget { set { return; } }
        public override bool PIDActive 
        { 
+<<<<<<< HEAD
+            get { return false; }
+=======
            // os version
            // get { return false; }
+>>>>>>> avn/ubitvar
            set { return; } 
        }
        public override float PIDTau { set { return; } }
diff --git a/OpenSim/Region/Physics/OdePlugin/ODEPrim.cs b/OpenSim/Region/Physics/OdePlugin/ODEPrim.cs
index 218ccda..6363422 100644
--- a/OpenSim/Region/Physics/OdePlugin/ODEPrim.cs
+++ b/OpenSim/Region/Physics/OdePlugin/ODEPrim.cs
@@ -114,7 +114,6 @@ namespace OpenSim.Region.Physics.OdePlugin
        private float m_PIDTau;
        private float PID_D = 35f;
        private float PID_G = 25f;
-        private bool m_usePID;
        // KF: These next 7 params apply to llSetHoverHeight(float height, integer water, float tau),
        // and are for non-VEHICLES only.
@@ -1731,7 +1730,7 @@ Console.WriteLine(" JointCreateFixed");
                    // gravityz multiplier = 1 - m_buoyancy
                    fz = _parent_scene.gravityz * (1.0f - m_buoyancy) * m_mass;
-                    if (m_usePID)
+                    if (PIDActive)
                    {
 //Console.WriteLine("PID " +  Name);
                        // KF - this is for object move? eg. llSetPos() ?
@@ -1803,7 +1802,7 @@ Console.WriteLine(" JointCreateFixed");
                    }        // end if (PIDActive)
                    // Hover PID Controller needs to be mutually exlusive to MoveTo PID controller
-                    if (m_useHoverPID && !m_usePID)
+                    if (m_useHoverPID && !PIDActive)
                    {
 //Console.WriteLine("Hover " +  Name);
                    
@@ -2875,7 +2874,7 @@ Console.WriteLine(" JointCreateFixed");
                        // it does make sense to do this for tiny little instabilities with physical prim, however 0.5m/frame is fairly large. 
                        // reducing this to 0.02m/frame seems to help the angular rubberbanding quite a bit, however, to make sure it doesn't affect elevators and vehicles
                        // adding these logical exclusion situations to maintain this where I think it was intended to be.
-                        if (m_throttleUpdates || m_usePID || (m_vehicle != null && m_vehicle.Type != Vehicle.TYPE_NONE) || (Amotor != IntPtr.Zero)) 
+                        if (m_throttleUpdates || PIDActive || (m_vehicle != null && m_vehicle.Type != Vehicle.TYPE_NONE) || (Amotor != IntPtr.Zero)) 
                        {
                            m_minvelocity = 0.5f;
                        }
@@ -2956,10 +2955,14 @@ Console.WriteLine(" JointCreateFixed");
                    m_log.WarnFormat("[PHYSICS]: Got NaN PIDTarget from Scene on Object {0}", Name);
            } 
        }
+<<<<<<< HEAD
+        public override bool PIDActive { get; set; }
+=======
        // os version
        //public override bool PIDActive {get { return m_usePID; } set { m_usePID = value; } }
        public override bool PIDActive { set { m_usePID = value; } }
+>>>>>>> avn/ubitvar
        public override float PIDTau { set { m_PIDTau = value; } }
        public override float PIDHoverHeight { set { m_PIDHoverHeight = value; ; } }
@@ -3356,10 +3359,14 @@ Console.WriteLine(" JointCreateFixed");
                        RequestAssetDelegate assetProvider = _parent_scene.RequestAssetMethod;
                        if (assetProvider != null)
                            assetProvider(_pbs.SculptTexture, MeshAssetReceived);
+<<<<<<< HEAD
+                    }, null, "ODEPrim.CheckMeshAsset");
+=======
                    // os version
                    //}, null, "ODEPrim.CheckMeshAsset");
                    // avn
                    });
+>>>>>>> avn/ubitvar
            }
        }
diff --git a/OpenSim/Region/Physics/OdePlugin/OdeScene.cs b/OpenSim/Region/Physics/OdePlugin/OdeScene.cs
index 820e649..7f4a809 100644
--- a/OpenSim/Region/Physics/OdePlugin/OdeScene.cs
+++ b/OpenSim/Region/Physics/OdePlugin/OdeScene.cs
@@ -2020,6 +2020,13 @@ namespace OpenSim.Region.Physics.OdePlugin
        #region Add/Remove Entities
+<<<<<<< HEAD
+        public override PhysicsActor AddAvatar(string avName, Vector3 position, Vector3 velocity, Vector3 size, bool isFlying)
+        {                       
+            OdeCharacter newAv
+                = new OdeCharacter(
+                    avName, this, position, velocity, size, avPIDD, avPIDP,
+=======
 /*  core version
        public override PhysicsActor AddAvatar(string avName, Vector3 position, Vector3 velocity, Vector3 size, bool isFlying)
        {                       
@@ -2041,6 +2048,7 @@ namespace OpenSim.Region.Physics.OdePlugin
            OdeCharacter newAv
                = new OdeCharacter(
                    avName, this, position, Vector3.Zero, size, avPIDD, avPIDP,
+>>>>>>> avn/ubitvar
                    avCapRadius, avStandupTensor, avDensity,
                    avMovementDivisorWalk, avMovementDivisorRun);
diff --git a/OpenSim/Region/Physics/POSPlugin/AssemblyInfo.cs b/OpenSim/Region/Physics/POSPlugin/AssemblyInfo.cs
index 83be103..fc1ffba 100644
--- a/OpenSim/Region/Physics/POSPlugin/AssemblyInfo.cs
+++ b/OpenSim/Region/Physics/POSPlugin/AssemblyInfo.cs
@@ -55,4 +55,4 @@ using System.Runtime.InteropServices;
 // You can specify all values by your own or you can build default build and revision
 // numbers with the '*' character (the default):
-[assembly : AssemblyVersion("0.8.0.*")]
+[assembly : AssemblyVersion("0.8.2.*")]
diff --git a/OpenSim/Region/Physics/POSPlugin/POSCharacter.cs b/OpenSim/Region/Physics/POSPlugin/POSCharacter.cs
index ae534ea..40ab984 100644
--- a/OpenSim/Region/Physics/POSPlugin/POSCharacter.cs
+++ b/OpenSim/Region/Physics/POSPlugin/POSCharacter.cs
@@ -273,9 +273,10 @@ namespace OpenSim.Region.Physics.POSPlugin
            set { return; }
        }
-        public override bool PIDActive
+        public override bool PIDActive 
-        {
+        { 
-            set { return; }
+            get { return false; }
+            set { return; } 
        }
        public override float PIDTau
diff --git a/OpenSim/Region/Physics/POSPlugin/POSPrim.cs b/OpenSim/Region/Physics/POSPlugin/POSPrim.cs
index 2ea8bfc..782ba82 100644
--- a/OpenSim/Region/Physics/POSPlugin/POSPrim.cs
+++ b/OpenSim/Region/Physics/POSPlugin/POSPrim.cs
@@ -270,6 +270,7 @@ namespace OpenSim.Region.Physics.POSPlugin
        public override bool PIDActive
        {
+            get { return false; }
            set { return; }
        }
diff --git a/OpenSim/Region/Physics/POSPlugin/POSScene.cs b/OpenSim/Region/Physics/POSPlugin/POSScene.cs
index d30d482..080c6ab 100644
--- a/OpenSim/Region/Physics/POSPlugin/POSScene.cs
+++ b/OpenSim/Region/Physics/POSPlugin/POSScene.cs
@@ -58,7 +58,8 @@ namespace OpenSim.Region.Physics.POSPlugin
        {
        }
-        public override PhysicsActor AddAvatar(string avName, Vector3 position, Vector3 size, bool isFlying)
+        public override PhysicsActor AddAvatar(
+            string avName, Vector3 position, Vector3 velocity, Vector3 size, bool isFlying)
        {
            POSCharacter act = new POSCharacter();
            act.Position = position;