Revert "Merge master into teravuswork", it should have been avination, not master.

This reverts commit dfac269032300872c4d0dc507f4f9062d102b0f4, reversing
changes made to 619c39e5144f15aca129d6d999bcc5c34133ee64.

20 files changed, 2360 insertions, 5509 deletions

diff --git a/OpenSim/Region/Physics/BulletSPlugin/BSConstraint6Dof.cs b/OpenSim/Region/Physics/BulletSPlugin/BS6DofConstraint.cs
index 23ef052..683bc51 100755
--- a/OpenSim/Region/Physics/BulletSPlugin/BSConstraint6Dof.cs
+++ b/OpenSim/Region/Physics/BulletSPlugin/BS6DofConstraint.cs
@@ -32,14 +32,10 @@ using OpenMetaverse;
 namespace OpenSim.Region.Physics.BulletSPlugin
 {
 
-public sealed class BSConstraint6Dof : BSConstraint
+public class BS6DofConstraint : BSConstraint
 {
-    private static string LogHeader = "[BULLETSIM 6DOF CONSTRAINT]";
-
-    public override ConstraintType Type { get { return ConstraintType.D6_CONSTRAINT_TYPE; } }
-
     // Create a btGeneric6DofConstraint
-    public BSConstraint6Dof(BulletSim world, BulletBody obj1, BulletBody obj2,
+    public BS6DofConstraint(BulletSim world, BulletBody obj1, BulletBody obj2,
                     Vector3 frame1, Quaternion frame1rot,
                     Vector3 frame2, Quaternion frame2rot,
                     bool useLinearReferenceFrameA, bool disableCollisionsBetweenLinkedBodies)
@@ -48,52 +44,25 @@ public sealed class BSConstraint6Dof : BSConstraint
         m_body1 = obj1;
         m_body2 = obj2;
         m_constraint = new BulletConstraint(
-                            BulletSimAPI.Create6DofConstraint2(m_world.ptr, m_body1.ptr, m_body2.ptr,
+                            BulletSimAPI.Create6DofConstraint2(m_world.Ptr, m_body1.Ptr, m_body2.Ptr,
                                 frame1, frame1rot,
                                 frame2, frame2rot,
                                 useLinearReferenceFrameA, disableCollisionsBetweenLinkedBodies));
         m_enabled = true;
-        world.physicsScene.DetailLog("{0},BS6DofConstraint,createFrame,wID={1}, rID={2}, rBody={3}, cID={4}, cBody={5}",
-                            BSScene.DetailLogZero, world.worldID,
-                            obj1.ID, obj1.ptr.ToString("X"), obj2.ID, obj2.ptr.ToString("X"));
     }
 
-    public BSConstraint6Dof(BulletSim world, BulletBody obj1, BulletBody obj2,
+    public BS6DofConstraint(BulletSim world, BulletBody obj1, BulletBody obj2,
                     Vector3 joinPoint,
                     bool useLinearReferenceFrameA, bool disableCollisionsBetweenLinkedBodies)
     {
         m_world = world;
         m_body1 = obj1;
         m_body2 = obj2;
-        if (obj1.ptr == IntPtr.Zero || obj2.ptr == IntPtr.Zero)
-        {
-            world.physicsScene.DetailLog("{0},BS6DOFConstraint,badBodyPtr,wID={1}, rID={2}, rBody={3}, cID={4}, cBody={5}",
-                            BSScene.DetailLogZero, world.worldID,
-                            obj1.ID, obj1.ptr.ToString("X"), obj2.ID, obj2.ptr.ToString("X"));
-            world.physicsScene.Logger.ErrorFormat("{0} Attempt to build 6DOF constraint with missing bodies: wID={1}, rID={2}, rBody={3}, cID={4}, cBody={5}",
-                            LogHeader, world.worldID, obj1.ID, obj1.ptr.ToString("X"), obj2.ID, obj2.ptr.ToString("X"));
-            m_enabled = false;
-        }
-        else
-        {
-            m_constraint = new BulletConstraint(
-                                BulletSimAPI.Create6DofConstraintToPoint2(m_world.ptr, m_body1.ptr, m_body2.ptr,
-                                    joinPoint,
-                                    useLinearReferenceFrameA, disableCollisionsBetweenLinkedBodies));
-            world.physicsScene.DetailLog("{0},BS6DofConstraint,createMidPoint,wID={1}, csrt={2}, rID={3}, rBody={4}, cID={5}, cBody={6}",
-                                BSScene.DetailLogZero, world.worldID, m_constraint.ptr.ToString("X"),
-                                obj1.ID, obj1.ptr.ToString("X"), obj2.ID, obj2.ptr.ToString("X"));
-            if (m_constraint.ptr == IntPtr.Zero)
-            {
-                world.physicsScene.Logger.ErrorFormat("{0} Failed creation of 6Dof constraint. rootID={1}, childID={2}",
-                                LogHeader, obj1.ID, obj2.ID);
-                m_enabled = false;
-            }
-            else
-            {
-                m_enabled = true;
-            }
-        }
+        m_constraint = new BulletConstraint(
+                            BulletSimAPI.Create6DofConstraintToPoint2(m_world.Ptr, m_body1.Ptr, m_body2.Ptr,
+                                joinPoint,
+                                useLinearReferenceFrameA, disableCollisionsBetweenLinkedBodies));
+        m_enabled = true;
     }
 
     public bool SetFrames(Vector3 frameA, Quaternion frameArot, Vector3 frameB, Quaternion frameBrot)
@@ -101,7 +70,7 @@ public sealed class BSConstraint6Dof : BSConstraint
         bool ret = false;
         if (m_enabled)
         {
-            BulletSimAPI.SetFrames2(m_constraint.ptr, frameA, frameArot, frameB, frameBrot);
+            BulletSimAPI.SetFrames2(m_constraint.Ptr, frameA, frameArot, frameB, frameBrot);
             ret = true;
         }
         return ret;
@@ -112,9 +81,9 @@ public sealed class BSConstraint6Dof : BSConstraint
         bool ret = false;
         if (m_enabled)
         {
-            BulletSimAPI.SetConstraintParam2(m_constraint.ptr, ConstraintParams.BT_CONSTRAINT_STOP_CFM, cfm, ConstraintParamAxis.AXIS_ALL);
-            BulletSimAPI.SetConstraintParam2(m_constraint.ptr, ConstraintParams.BT_CONSTRAINT_STOP_ERP, erp, ConstraintParamAxis.AXIS_ALL);
-            BulletSimAPI.SetConstraintParam2(m_constraint.ptr, ConstraintParams.BT_CONSTRAINT_CFM, cfm, ConstraintParamAxis.AXIS_ALL);
+            BulletSimAPI.SetConstraintParam2(m_constraint.Ptr, ConstraintParams.BT_CONSTRAINT_STOP_CFM, cfm, ConstraintParamAxis.AXIS_ALL);
+            BulletSimAPI.SetConstraintParam2(m_constraint.Ptr, ConstraintParams.BT_CONSTRAINT_STOP_ERP, erp, ConstraintParamAxis.AXIS_ALL);
+            BulletSimAPI.SetConstraintParam2(m_constraint.Ptr, ConstraintParams.BT_CONSTRAINT_CFM, cfm, ConstraintParamAxis.AXIS_ALL);
             ret = true;
         }
         return ret;
@@ -125,7 +94,7 @@ public sealed class BSConstraint6Dof : BSConstraint
         bool ret = false;
         float onOff = useOffset ? ConfigurationParameters.numericTrue : ConfigurationParameters.numericFalse;
         if (m_enabled)
-            ret = BulletSimAPI.UseFrameOffset2(m_constraint.ptr, onOff);
+            ret = BulletSimAPI.UseFrameOffset2(m_constraint.Ptr, onOff);
         return ret;
     }
 
@@ -134,11 +103,7 @@ public sealed class BSConstraint6Dof : BSConstraint
         bool ret = false;
         float onOff = enable ? ConfigurationParameters.numericTrue : ConfigurationParameters.numericFalse;
         if (m_enabled)
-        {
-            ret = BulletSimAPI.TranslationalLimitMotor2(m_constraint.ptr, onOff, targetVelocity, maxMotorForce);
-            m_world.physicsScene.DetailLog("{0},BS6DOFConstraint,TransLimitMotor,enable={1},vel={2},maxForce={3}",
-                            BSScene.DetailLogZero, enable, targetVelocity, maxMotorForce);
-        }
+            ret = BulletSimAPI.TranslationalLimitMotor2(m_constraint.Ptr, onOff, targetVelocity, maxMotorForce);
         return ret;
     }
 
@@ -146,7 +111,7 @@ public sealed class BSConstraint6Dof : BSConstraint
     {
         bool ret = false;
         if (m_enabled)
-            ret = BulletSimAPI.SetBreakingImpulseThreshold2(m_constraint.ptr, threshold);
+            ret = BulletSimAPI.SetBreakingImpulseThreshold2(m_constraint.Ptr, threshold);
         return ret;
     }
 }
diff --git a/OpenSim/Region/Physics/BulletSPlugin/BSCharacter.cs b/OpenSim/Region/Physics/BulletSPlugin/BSCharacter.cs
index 2a5397e..e2f7af9 100644
--- a/OpenSim/Region/Physics/BulletSPlugin/BSCharacter.cs
+++ b/OpenSim/Region/Physics/BulletSPlugin/BSCharacter.cs
@@ -28,48 +28,62 @@ using System;
 using System.Collections.Generic;
 using System.Reflection;
 using log4net;
-using OMV = OpenMetaverse;
+using OpenMetaverse;
 using OpenSim.Framework;
 using OpenSim.Region.Physics.Manager;
 
 namespace OpenSim.Region.Physics.BulletSPlugin
 {
-public sealed class BSCharacter : BSPhysObject
+public class BSCharacter : PhysicsActor
 {
     private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
     private static readonly string LogHeader = "[BULLETS CHAR]";
 
+    private BSScene _scene;
+    public BSScene Scene { get { return _scene; } }
+    private String _avName;
     // private bool _stopped;
-    private OMV.Vector3 _size;
+    private Vector3 _size;
+    private Vector3 _scale;
+    private PrimitiveBaseShape _pbs;
+    private uint _localID = 0;
     private bool _grabbed;
     private bool _selected;
-    private OMV.Vector3 _position;
+    private Vector3 _position;
     private float _mass;
-    private float _avatarDensity;
-    private float _avatarVolume;
-    private OMV.Vector3 _force;
-    private OMV.Vector3 _velocity;
-    private OMV.Vector3 _torque;
+    public float _density;
+    public float _avatarVolume;
+    private Vector3 _force;
+    private Vector3 _velocity;
+    private Vector3 _torque;
     private float _collisionScore;
-    private OMV.Vector3 _acceleration;
-    private OMV.Quaternion _orientation;
+    private Vector3 _acceleration;
+    private Quaternion _orientation;
     private int _physicsActorType;
     private bool _isPhysical;
     private bool _flying;
     private bool _setAlwaysRun;
     private bool _throttleUpdates;
     private bool _isColliding;
+    private long _collidingStep;
+    private bool _collidingGround;
+    private long _collidingGroundStep;
     private bool _collidingObj;
     private bool _floatOnWater;
-    private OMV.Vector3 _rotationalVelocity;
+    private Vector3 _rotationalVelocity;
     private bool _kinematic;
     private float _buoyancy;
 
-    // The friction and velocity of the avatar is modified depending on whether walking or not.
-    private OMV.Vector3 _appliedVelocity;   // the last velocity applied to the avatar
-    private float _currentFriction;         // the friction currently being used (changed by setVelocity).
+    private BulletBody m_body;
+    public BulletBody Body { 
+        get { return m_body; }
+        set { m_body = value; }
+    }
+
+    private int _subscribedEventsMs = 0;
+    private int _nextCollisionOkTime = 0;
 
-    private OMV.Vector3 _PIDTarget;
+    private Vector3 _PIDTarget;
     private bool _usePID;
     private float _PIDTau;
     private bool _useHoverPID;
@@ -77,507 +91,332 @@ public sealed class BSCharacter : BSPhysObject
     private PIDHoverType _PIDHoverType;
     private float _PIDHoverTao;
 
-    public BSCharacter(uint localID, String avName, BSScene parent_scene, OMV.Vector3 pos, OMV.Vector3 size, bool isFlying)
+    public BSCharacter(uint localID, String avName, BSScene parent_scene, Vector3 pos, Vector3 size, bool isFlying)
     {
-        base.BaseInitialize(parent_scene, localID, avName, "BSCharacter");
-        _physicsActorType = (int)ActorTypes.Agent;
+        _localID = localID;
+        _avName = avName;
+        _scene = parent_scene;
         _position = pos;
         _size = size;
         _flying = isFlying;
-        _orientation = OMV.Quaternion.Identity;
-        _velocity = OMV.Vector3.Zero;
-        _appliedVelocity = OMV.Vector3.Zero;
+        _orientation = Quaternion.Identity;
+        _velocity = Vector3.Zero;
         _buoyancy = ComputeBuoyancyFromFlying(isFlying);
-        _currentFriction = PhysicsScene.Params.avatarStandingFriction;
-        _avatarDensity = PhysicsScene.Params.avatarDensity;
-
         // The dimensions of the avatar capsule are kept in the scale.
         // Physics creates a unit capsule which is scaled by the physics engine.
-        ComputeAvatarScale(_size);
-        // 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}",
-                            LocalID, _size, Scale, _avatarDensity, _avatarVolume, RawMass);
+        _scale = new Vector3(_scene.Params.avatarCapsuleRadius, _scene.Params.avatarCapsuleRadius, size.Z);
+        _density = _scene.Params.avatarDensity;
+        ComputeAvatarVolumeAndMass();   // set _avatarVolume and _mass based on capsule size, _density and _scale
+
+        ShapeData shapeData = new ShapeData();
+        shapeData.ID = _localID;
+        shapeData.Type = ShapeData.PhysicsShapeType.SHAPE_AVATAR;
+        shapeData.Position = _position;
+        shapeData.Rotation = _orientation;
+        shapeData.Velocity = _velocity;
+        shapeData.Scale = _scale;
+        shapeData.Mass = _mass;
+        shapeData.Buoyancy = _buoyancy;
+        shapeData.Static = ShapeData.numericFalse;
+        shapeData.Friction = _scene.Params.avatarFriction;
+        shapeData.Restitution = _scene.Params.avatarRestitution;
 
         // do actual create at taint time
-        PhysicsScene.TaintedObject("BSCharacter.create", delegate()
+        _scene.TaintedObject("BSCharacter.create", delegate()
         {
-            DetailLog("{0},BSCharacter.create,taint", LocalID);
-            // New body and shape into BSBody and BSShape
-            PhysicsScene.Shapes.GetBodyAndShape(true, PhysicsScene.World, this, null, null);
+            BulletSimAPI.CreateObject(parent_scene.WorldID, shapeData);
 
-            SetPhysicalProperties();
+            m_body = new BulletBody(LocalID, BulletSimAPI.GetBodyHandle2(_scene.World.Ptr, LocalID));
+            // avatars get all collisions no matter what
+            BulletSimAPI.AddToCollisionFlags2(Body.Ptr, CollisionFlags.BS_SUBSCRIBE_COLLISION_EVENTS);
         });
+            
         return;
     }
 
     // called when this character is being destroyed and the resources should be released
-    public override void Destroy()
+    public void Destroy()
     {
-        DetailLog("{0},BSCharacter.Destroy", LocalID);
-        PhysicsScene.TaintedObject("BSCharacter.destroy", delegate()
+        // DetailLog("{0},BSCharacter.Destroy", LocalID);
+        _scene.TaintedObject("BSCharacter.destroy", delegate()
         {
-            PhysicsScene.Shapes.DereferenceBody(PhysBody, true, null);
-            PhysicsScene.Shapes.DereferenceShape(PhysShape, true, null);
+            BulletSimAPI.DestroyObject(_scene.WorldID, _localID);
         });
     }
 
-    private void SetPhysicalProperties()
-    {
-        BulletSimAPI.RemoveObjectFromWorld2(PhysicsScene.World.ptr, PhysBody.ptr);
-
-        ZeroMotion();
-        ForcePosition = _position;
-        // Set the velocity and compute the proper friction
-        ForceVelocity = _velocity;
-
-        BulletSimAPI.SetRestitution2(PhysBody.ptr, PhysicsScene.Params.avatarRestitution);
-        BulletSimAPI.SetMargin2(PhysShape.ptr, PhysicsScene.Params.collisionMargin);
-        BulletSimAPI.SetLocalScaling2(PhysShape.ptr, Scale);
-        BulletSimAPI.SetContactProcessingThreshold2(PhysBody.ptr, PhysicsScene.Params.contactProcessingThreshold);
-        if (PhysicsScene.Params.ccdMotionThreshold > 0f)
-        {
-            BulletSimAPI.SetCcdMotionThreshold2(PhysBody.ptr, PhysicsScene.Params.ccdMotionThreshold);
-            BulletSimAPI.SetCcdSweptSphereRadius2(PhysBody.ptr, PhysicsScene.Params.ccdSweptSphereRadius);
-        }
-
-        UpdatePhysicalMassProperties(RawMass);
-
-        // Make so capsule does not fall over
-        BulletSimAPI.SetAngularFactorV2(PhysBody.ptr, OMV.Vector3.Zero);
-
-        BulletSimAPI.AddToCollisionFlags2(PhysBody.ptr, CollisionFlags.CF_CHARACTER_OBJECT);
-
-        BulletSimAPI.AddObjectToWorld2(PhysicsScene.World.ptr, PhysBody.ptr);
-
-        // BulletSimAPI.ForceActivationState2(BSBody.ptr, ActivationState.ACTIVE_TAG);
-        BulletSimAPI.ForceActivationState2(PhysBody.ptr, ActivationState.DISABLE_DEACTIVATION);
-        BulletSimAPI.UpdateSingleAabb2(PhysicsScene.World.ptr, PhysBody.ptr);
-
-        // Do this after the object has been added to the world
-        BulletSimAPI.SetCollisionFilterMask2(PhysBody.ptr,
-                        (uint)CollisionFilterGroups.AvatarFilter,
-                        (uint)CollisionFilterGroups.AvatarMask);
-    }
-
     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; } }
-
-    public override OMV.Vector3 Size {
+    public override bool Stopped { 
+        get { return false; } 
+    }
+    public override Vector3 Size {
         get
         {
             // Avatar capsule size is kept in the scale parameter.
-            // return _size;
-            return new OMV.Vector3(Scale.X * 2f, Scale.Y * 2f, Scale.Z);
+            return new Vector3(_scale.X * 2, _scale.Y * 2, _scale.Z);
         }
 
-        set {
-            // When an avatar's size is set, only the height is changed.
+        set { 
+            // When an avatar's size is set, only the height is changed
+            //    and that really only depends on the radius.
             _size = value;
-            ComputeAvatarScale(_size);
+            _scale.Z = (_size.Z * 1.15f) - (_scale.X + _scale.Y);
+
+            // TODO: something has to be done with the avatar's vertical position
+
             ComputeAvatarVolumeAndMass();
-            DetailLog("{0},BSCharacter.setSize,call,scale={1},density={2},volume={3},mass={4}",
-                            LocalID, Scale, _avatarDensity, _avatarVolume, RawMass);
 
-            PhysicsScene.TaintedObject("BSCharacter.setSize", delegate()
+            _scene.TaintedObject("BSCharacter.setSize", delegate()
             {
-                BulletSimAPI.SetLocalScaling2(PhysShape.ptr, Scale);
-                UpdatePhysicalMassProperties(RawMass);
+                BulletSimAPI.SetObjectScaleMass(_scene.WorldID, LocalID, _scale, _mass, true);
             });
 
-        }
+        } 
     }
-
-    public override OMV.Vector3 Scale { get; set; }
-
-    public override PrimitiveBaseShape Shape
-    {
-        set { BaseShape = value; }
+    public override PrimitiveBaseShape Shape { 
+        set { _pbs = value; 
+        } 
     }
-    // I want the physics engine to make an avatar capsule
-    public override ShapeData.PhysicsShapeType PreferredPhysicalShape
-    {
-        get {return ShapeData.PhysicsShapeType.SHAPE_AVATAR; }
+    public override uint LocalID { 
+        set { _localID = value; 
+        }
+        get { return _localID; }
     }
-
-    public override bool Grabbed {
-        set { _grabbed = value; }
+    public override bool Grabbed { 
+        set { _grabbed = value; 
+        } 
     }
-    public override bool Selected {
-        set { _selected = value; }
+    public override bool Selected { 
+        set { _selected = value; 
+        } 
     }
     public override void CrossingFailure() { return; }
     public override void link(PhysicsActor obj) { return; }
     public override void delink() { return; }
+    public override void LockAngularMotion(Vector3 axis) { return; }
 
-    // Set motion values to zero.
-    // Do it to the properties so the values get set in the physics engine.
-    // Push the setting of the values to the viewer.
-    // Called at taint time!
-    public override void ZeroMotion()
-    {
-        _velocity = OMV.Vector3.Zero;
-        _acceleration = OMV.Vector3.Zero;
-        _rotationalVelocity = OMV.Vector3.Zero;
-
-        // Zero some other properties directly into the physics engine
-        BulletSimAPI.SetLinearVelocity2(PhysBody.ptr, OMV.Vector3.Zero);
-        BulletSimAPI.SetAngularVelocity2(PhysBody.ptr, OMV.Vector3.Zero);
-        BulletSimAPI.SetInterpolationVelocity2(PhysBody.ptr, OMV.Vector3.Zero, OMV.Vector3.Zero);
-        BulletSimAPI.ClearForces2(PhysBody.ptr);
-    }
-
-    public override void LockAngularMotion(OMV.Vector3 axis) { return; }
-
-    public override OMV.Vector3 RawPosition
-    {
-        get { return _position; }
-        set { _position = value; }
-    }
-    public override OMV.Vector3 Position {
+    public override Vector3 Position { 
         get {
-            // Don't refetch the position because this function is called a zillion times
-            // _position = BulletSimAPI.GetObjectPosition2(Scene.World.ptr, LocalID);
-            return _position;
-        }
+            // _position = BulletSimAPI.GetObjectPosition(_scene.WorldID, _localID);
+            return _position; 
+        } 
         set {
             _position = value;
             PositionSanityCheck();
 
-            PhysicsScene.TaintedObject("BSCharacter.setPosition", delegate()
+            _scene.TaintedObject("BSCharacter.setPosition", delegate()
             {
                 DetailLog("{0},BSCharacter.SetPosition,taint,pos={1},orient={2}", LocalID, _position, _orientation);
-                BulletSimAPI.SetTranslation2(PhysBody.ptr, _position, _orientation);
+                BulletSimAPI.SetObjectTranslation(_scene.WorldID, _localID, _position, _orientation);
             });
-        }
-    }
-    public override OMV.Vector3 ForcePosition {
-        get {
-            _position = BulletSimAPI.GetPosition2(PhysBody.ptr);
-            return _position;
-        }
-        set {
-            _position = value;
-            PositionSanityCheck();
-            BulletSimAPI.SetTranslation2(PhysBody.ptr, _position, _orientation);
-        }
+        } 
     }
 
-
     // Check that the current position is sane and, if not, modify the position to make it so.
-    // Check for being below terrain or on water.
+    // Check for being below terrain and being out of bounds.
     // Returns 'true' of the position was made sane by some action.
     private bool PositionSanityCheck()
     {
         bool ret = false;
-
+        
         // If below the ground, move the avatar up
-        float terrainHeight = PhysicsScene.TerrainManager.GetTerrainHeightAtXYZ(_position);
-        if (Position.Z < terrainHeight)
+        float terrainHeight = Scene.GetTerrainHeightAtXYZ(_position);
+        if (_position.Z < terrainHeight)
         {
-            DetailLog("{0},BSCharacter.PositionAdjustUnderGround,call,pos={1},terrain={2}", LocalID, _position, terrainHeight);
+            DetailLog("{0},BSCharacter.PositionAdjustUnderGround,call,pos={1},orient={2}", LocalID, _position, _orientation);
             _position.Z = terrainHeight + 2.0f;
             ret = true;
         }
-        if ((CurrentCollisionFlags & CollisionFlags.BS_FLOATS_ON_WATER) != 0)
-        {
-            float waterHeight = PhysicsScene.GetWaterLevelAtXYZ(_position);
-            if (Position.Z < waterHeight)
-            {
-                _position.Z = waterHeight;
-                ret = true;
-            }
-        }
 
         // TODO: check for out of bounds
-        return ret;
-    }
 
-    // A version of the sanity check that also makes sure a new position value is
-    //    pushed back to the physics engine. This routine would be used by anyone
-    //    who is not already pushing the value.
-    private bool PositionSanityCheck(bool inTaintTime)
-    {
-        bool ret = false;
-        if (PositionSanityCheck())
-        {
-            // The new position value must be pushed into the physics engine but we can't
-            //    just assign to "Position" because of potential call loops.
-            PhysicsScene.TaintedObject(inTaintTime, "BSCharacter.PositionSanityCheck", delegate()
-            {
-                DetailLog("{0},BSCharacter.PositionSanityCheck,taint,pos={1},orient={2}", LocalID, _position, _orientation);
-                BulletSimAPI.SetTranslation2(PhysBody.ptr, _position, _orientation);
-            });
-            ret = true;
-        }
         return ret;
     }
 
-    public override float Mass { get { return _mass; } }
-
-    // used when we only want this prim's mass and not the linkset thing
-    public override float RawMass { 
-        get {return _mass; }
-    }
-    public override void UpdatePhysicalMassProperties(float physMass)
-    {
-        OMV.Vector3 localInertia = BulletSimAPI.CalculateLocalInertia2(PhysShape.ptr, physMass);
-        BulletSimAPI.SetMassProps2(PhysBody.ptr, physMass, localInertia);
+    public override float Mass { 
+        get { 
+            return _mass; 
+        } 
     }
-
-    public override OMV.Vector3 Force {
-        get { return _force; }
+    public override Vector3 Force { 
+        get { return _force; } 
         set {
             _force = value;
             // m_log.DebugFormat("{0}: Force = {1}", LogHeader, _force);
-            PhysicsScene.TaintedObject("BSCharacter.SetForce", delegate()
+            Scene.TaintedObject("BSCharacter.SetForce", delegate()
             {
                 DetailLog("{0},BSCharacter.setForce,taint,force={1}", LocalID, _force);
-                BulletSimAPI.SetObjectForce2(PhysBody.ptr, _force);
+                BulletSimAPI.SetObjectForce(Scene.WorldID, LocalID, _force);
             });
-        }
+        } 
     }
 
-    // Avatars don't do vehicles
-    public override int VehicleType { get { return (int)Vehicle.TYPE_NONE; } set { return; } }
+    public override int VehicleType { 
+        get { return 0; } 
+        set { return; } 
+    }
     public override void VehicleFloatParam(int param, float value) { }
-    public override void VehicleVectorParam(int param, OMV.Vector3 value) {}
-    public override void VehicleRotationParam(int param, OMV.Quaternion rotation) { }
+    public override void VehicleVectorParam(int param, Vector3 value) {}
+    public override void VehicleRotationParam(int param, Quaternion rotation) { }
     public override void VehicleFlags(int param, bool remove) { }
 
     // Allows the detection of collisions with inherently non-physical prims. see llVolumeDetect for more
     public override void SetVolumeDetect(int param) { return; }
 
-    public override OMV.Vector3 GeometricCenter { get { return OMV.Vector3.Zero; } }
-    public override OMV.Vector3 CenterOfMass { get { return OMV.Vector3.Zero; } }
-    public override OMV.Vector3 Velocity {
-        get { return _velocity; }
+    public override Vector3 GeometricCenter { get { return Vector3.Zero; } }
+    public override Vector3 CenterOfMass { get { return Vector3.Zero; } }
+    public override Vector3 Velocity { 
+        get { return _velocity; } 
         set {
             _velocity = value;
             // m_log.DebugFormat("{0}: set velocity = {1}", LogHeader, _velocity);
-            PhysicsScene.TaintedObject("BSCharacter.setVelocity", delegate()
+            _scene.TaintedObject("BSCharacter.setVelocity", delegate()
             {
                 DetailLog("{0},BSCharacter.setVelocity,taint,vel={1}", LocalID, _velocity);
-                ForceVelocity = _velocity;
+                BulletSimAPI.SetObjectVelocity(_scene.WorldID, _localID, _velocity);
             });
-        }
-    }
-    public override OMV.Vector3 ForceVelocity {
-        get { return _velocity; }
-        set {
-            // Depending on whether the avatar is moving or not, change the friction
-            //    to keep the avatar from slipping around
-            if (_velocity.Length() == 0)
-            {
-                if (_currentFriction != PhysicsScene.Params.avatarStandingFriction)
-                {
-                    _currentFriction = PhysicsScene.Params.avatarStandingFriction;
-                    BulletSimAPI.SetFriction2(PhysBody.ptr, _currentFriction);
-                }
-            }
-            else
-            {
-                if (_currentFriction != PhysicsScene.Params.avatarFriction)
-                {
-                    _currentFriction = PhysicsScene.Params.avatarFriction;
-                    BulletSimAPI.SetFriction2(PhysBody.ptr, _currentFriction);
-                }
-            }
-            _velocity = value;
-            // Remember the set velocity so we can suppress the reduction by friction, ...
-            _appliedVelocity = value;
-
-            BulletSimAPI.SetLinearVelocity2(PhysBody.ptr, _velocity);
-            BulletSimAPI.Activate2(PhysBody.ptr, true);
-        }
+        } 
     }
-    public override OMV.Vector3 Torque {
-        get { return _torque; }
-        set { _torque = value;
-        }
+    public override Vector3 Torque { 
+        get { return _torque; } 
+        set { _torque = value; 
+        } 
     }
-    public override float CollisionScore {
-        get { return _collisionScore; }
-        set { _collisionScore = value;
-        }
+    public override float CollisionScore { 
+        get { return _collisionScore; } 
+        set { _collisionScore = value; 
+        } 
     }
-    public override OMV.Vector3 Acceleration {
+    public override Vector3 Acceleration { 
         get { return _acceleration; }
         set { _acceleration = value; }
     }
-    public override OMV.Quaternion RawOrientation
-    {
-        get { return _orientation; }
-        set { _orientation = value; }
-    }
-    public override OMV.Quaternion Orientation {
-        get { return _orientation; }
+    public override Quaternion Orientation { 
+        get { return _orientation; } 
         set {
             _orientation = value;
             // m_log.DebugFormat("{0}: set orientation to {1}", LogHeader, _orientation);
-            PhysicsScene.TaintedObject("BSCharacter.setOrientation", delegate()
+            _scene.TaintedObject("BSCharacter.setOrientation", delegate()
             {
-                // _position = BulletSimAPI.GetPosition2(BSBody.ptr);
-                BulletSimAPI.SetTranslation2(PhysBody.ptr, _position, _orientation);
+                // _position = BulletSimAPI.GetObjectPosition(_scene.WorldID, _localID);
+                BulletSimAPI.SetObjectTranslation(_scene.WorldID, _localID, _position, _orientation);
             });
-        }
+        } 
     }
-    // Go directly to Bullet to get/set the value.
-    public override OMV.Quaternion ForceOrientation
-    {
-        get
-        {
-            _orientation = BulletSimAPI.GetOrientation2(PhysBody.ptr);
-            return _orientation;
-        }
-        set
-        {
-            _orientation = value;
-            BulletSimAPI.SetTranslation2(PhysBody.ptr, _position, _orientation);
-        }
-    }
-    public override int PhysicsActorType {
-        get { return _physicsActorType; }
-        set { _physicsActorType = value;
-        }
+    public override int PhysicsActorType { 
+        get { return _physicsActorType; } 
+        set { _physicsActorType = value; 
+        } 
     }
-    public override bool IsPhysical {
-        get { return _isPhysical; }
+    public override bool IsPhysical { 
+        get { return _isPhysical; } 
         set { _isPhysical = value;
-        }
-    }
-    public override bool IsSolid {
-        get { return true; }
+        } 
     }
-    public override bool IsStatic {
-        get { return false; }
-    }
-    public override bool Flying {
-        get { return _flying; }
+    public override bool Flying { 
+        get { return _flying; } 
         set {
-            _flying = value;
-            // simulate flying by changing the effect of gravity
-            Buoyancy = ComputeBuoyancyFromFlying(_flying);
-        }
+            if (_flying != value)
+            {
+                _flying = value;
+                // simulate flying by changing the effect of gravity
+                this.Buoyancy = ComputeBuoyancyFromFlying(_flying);
+            }
+        } 
     }
-    // Flying is implimented by changing the avatar's buoyancy.
-    // Would this be done better with a vehicle type?
     private float ComputeBuoyancyFromFlying(bool ifFlying) {
         return ifFlying ? 1f : 0f;
     }
-    public override bool
-        SetAlwaysRun {
-        get { return _setAlwaysRun; }
-        set { _setAlwaysRun = value; }
+    public override bool 
+        SetAlwaysRun { 
+        get { return _setAlwaysRun; } 
+        set { _setAlwaysRun = value; } 
     }
-    public override bool ThrottleUpdates {
-        get { return _throttleUpdates; }
-        set { _throttleUpdates = value; }
+    public override bool ThrottleUpdates { 
+        get { return _throttleUpdates; } 
+        set { _throttleUpdates = value; } 
     }
     public override bool IsColliding {
-        get { return (CollidingStep == PhysicsScene.SimulationStep); }
-        set { _isColliding = value; }
+        get { return (_collidingStep == _scene.SimulationStep); } 
+        set { _isColliding = value; } 
     }
     public override bool CollidingGround {
-        get { return (CollidingGroundStep == PhysicsScene.SimulationStep); }
-        set { CollidingGround = value; }
-    }
-    public override bool CollidingObj {
-        get { return _collidingObj; }
-        set { _collidingObj = value; }
+        get { return (_collidingGroundStep == _scene.SimulationStep); } 
+        set { _collidingGround = value; } 
     }
-    public override bool FloatOnWater {
-        set {
-            _floatOnWater = value;
-            PhysicsScene.TaintedObject("BSCharacter.setFloatOnWater", delegate()
-            {
-                if (_floatOnWater)
-                    CurrentCollisionFlags = BulletSimAPI.AddToCollisionFlags2(PhysBody.ptr, CollisionFlags.BS_FLOATS_ON_WATER);
-                else
-                    CurrentCollisionFlags = BulletSimAPI.RemoveFromCollisionFlags2(PhysBody.ptr, CollisionFlags.BS_FLOATS_ON_WATER);
-            });
-        }
+    public override bool CollidingObj { 
+        get { return _collidingObj; } 
+        set { _collidingObj = value; } 
     }
-    public override OMV.Vector3 RotationalVelocity {
-        get { return _rotationalVelocity; }
-        set { _rotationalVelocity = value; }
+    public override bool FloatOnWater { 
+        set { _floatOnWater = value; } 
     }
-    public override OMV.Vector3 ForceRotationalVelocity {
-        get { return _rotationalVelocity; }
-        set { _rotationalVelocity = value; }
+    public override Vector3 RotationalVelocity { 
+        get { return _rotationalVelocity; } 
+        set { _rotationalVelocity = value; } 
     }
-    public override bool Kinematic {
-        get { return _kinematic; }
-        set { _kinematic = value; }
+    public override bool Kinematic { 
+        get { return _kinematic; } 
+        set { _kinematic = value; } 
     }
     // neg=fall quickly, 0=1g, 1=0g, pos=float up
-    public override float Buoyancy {
-        get { return _buoyancy; }
-        set { _buoyancy = value;
-            PhysicsScene.TaintedObject("BSCharacter.setBuoyancy", delegate()
+    public override float Buoyancy { 
+        get { return _buoyancy; } 
+        set { _buoyancy = value; 
+            _scene.TaintedObject("BSCharacter.setBuoyancy", delegate()
             {
                 DetailLog("{0},BSCharacter.setBuoyancy,taint,buoy={1}", LocalID, _buoyancy);
-                ForceBuoyancy = _buoyancy;
+                BulletSimAPI.SetObjectBuoyancy(_scene.WorldID, LocalID, _buoyancy);
             });
-        }
-    }
-    public override float ForceBuoyancy {
-        get { return _buoyancy; }
-        set { _buoyancy = value;
-            DetailLog("{0},BSCharacter.setForceBuoyancy,taint,buoy={1}", LocalID, _buoyancy);
-            // Buoyancy is faked by changing the gravity applied to the object
-            float grav = PhysicsScene.Params.gravity * (1f - _buoyancy);
-            BulletSimAPI.SetGravity2(PhysBody.ptr, new OMV.Vector3(0f, 0f, grav));
-        }
+        } 
     }
 
     // Used for MoveTo
-    public override OMV.Vector3 PIDTarget {
-        set { _PIDTarget = value; }
+    public override Vector3 PIDTarget { 
+        set { _PIDTarget = value; } 
     }
-    public override bool PIDActive {
-        set { _usePID = value; }
+    public override bool PIDActive { 
+        set { _usePID = value; } 
     }
-    public override float PIDTau {
-        set { _PIDTau = value; }
+    public override float PIDTau { 
+        set { _PIDTau = value; } 
     }
 
     // Used for llSetHoverHeight and maybe vehicle height
     // Hover Height will override MoveTo target's Z
-    public override bool PIDHoverActive {
+    public override bool PIDHoverActive { 
         set { _useHoverPID = value; }
     }
-    public override float PIDHoverHeight {
+    public override float PIDHoverHeight { 
         set { _PIDHoverHeight = value; }
     }
-    public override PIDHoverType PIDHoverType {
+    public override PIDHoverType PIDHoverType { 
         set { _PIDHoverType = value; }
     }
-    public override float PIDHoverTau {
+    public override float PIDHoverTau { 
         set { _PIDHoverTao = value; }
     }
 
     // For RotLookAt
-    public override OMV.Quaternion APIDTarget { set { return; } }
+    public override Quaternion APIDTarget { set { return; } }
     public override bool APIDActive { set { return; } }
     public override float APIDStrength { set { return; } }
     public override float APIDDamping { set { return; } }
 
-    public override void AddForce(OMV.Vector3 force, bool pushforce) {
+    public override void AddForce(Vector3 force, bool pushforce) { 
         if (force.IsFinite())
         {
             _force.X += force.X;
             _force.Y += force.Y;
             _force.Z += force.Z;
             // m_log.DebugFormat("{0}: AddForce. adding={1}, newForce={2}", LogHeader, force, _force);
-            PhysicsScene.TaintedObject("BSCharacter.AddForce", delegate()
+            _scene.TaintedObject("BSCharacter.AddForce", delegate()
             {
                 DetailLog("{0},BSCharacter.setAddForce,taint,addedForce={1}", LocalID, _force);
-                BulletSimAPI.SetObjectForce2(PhysBody.ptr, _force);
+                BulletSimAPI.AddObjectForce2(Body.Ptr, _force);
             });
         }
         else
@@ -587,75 +426,129 @@ public sealed class BSCharacter : BSPhysObject
         //m_lastUpdateSent = false;
     }
 
-    public override void AddAngularForce(OMV.Vector3 force, bool pushforce) {
+    public override void AddAngularForce(Vector3 force, bool pushforce) { 
     }
-    public override void SetMomentum(OMV.Vector3 momentum) {
+    public override void SetMomentum(Vector3 momentum) { 
     }
 
-    private void ComputeAvatarScale(OMV.Vector3 size)
-    {
-        // The 'size' given by the simulator is the mid-point of the avatar
-        //    and X and Y are unspecified.
-
-        OMV.Vector3 newScale = OMV.Vector3.Zero;
-        newScale.X = PhysicsScene.Params.avatarCapsuleRadius;
-        newScale.Y = PhysicsScene.Params.avatarCapsuleRadius;
+    // Turn on collision events at a rate no faster than one every the given milliseconds
+    public override void SubscribeEvents(int ms) {
+        _subscribedEventsMs = ms;
+        if (ms > 0)
+        {
+            // make sure first collision happens
+            _nextCollisionOkTime = Util.EnvironmentTickCount() - _subscribedEventsMs;
 
-        // From the total height, remove the capsule half spheres that are at each end
-        newScale.Z = size.Z- (newScale.X + newScale.Y);
-        Scale = newScale;
+            Scene.TaintedObject("BSCharacter.SubscribeEvents", delegate()
+            {
+                BulletSimAPI.AddToCollisionFlags2(Body.Ptr, CollisionFlags.BS_SUBSCRIBE_COLLISION_EVENTS);
+            });
+        }
+    }
+    // Stop collision events
+    public override void UnSubscribeEvents() { 
+        _subscribedEventsMs = 0;
+        // Avatars get all their collision events
+        // Scene.TaintedObject("BSCharacter.UnSubscribeEvents", delegate()
+        // {
+        //     BulletSimAPI.RemoveFromCollisionFlags2(Body.Ptr, CollisionFlags.BS_SUBSCRIBE_COLLISION_EVENTS);
+        // });
+    }
+    // Return 'true' if someone has subscribed to events
+    public override bool SubscribedEvents() {
+        return (_subscribedEventsMs > 0);
     }
 
-    // set _avatarVolume and _mass based on capsule size, _density and Scale
+    // set _avatarVolume and _mass based on capsule size, _density and _scale
     private void ComputeAvatarVolumeAndMass()
     {
         _avatarVolume = (float)(
                         Math.PI
-                        * Scale.X
-                        * Scale.Y    // the area of capsule cylinder
-                        * Scale.Z    // times height of capsule cylinder
+                        * _scale.X
+                        * _scale.Y  // the area of capsule cylinder
+                        * _scale.Z  // times height of capsule cylinder
                       + 1.33333333f
                         * Math.PI
-                        * Scale.X
-                        * Math.Min(Scale.X, Scale.Y)
-                        * Scale.Y    // plus the volume of the capsule end caps
+                        * _scale.X
+                        * Math.Min(_scale.X, _scale.Y)
+                        * _scale.Y  // plus the volume of the capsule end caps
                         );
-        _mass = _avatarDensity * _avatarVolume;
+        _mass = _density * _avatarVolume;
     }
 
     // The physics engine says that properties have updated. Update same and inform
     // the world that things have changed.
-    public override void UpdateProperties(EntityProperties entprop)
+    public void UpdateProperties(EntityProperties entprop)
     {
         _position = entprop.Position;
         _orientation = entprop.Rotation;
         _velocity = entprop.Velocity;
         _acceleration = entprop.Acceleration;
         _rotationalVelocity = entprop.RotationalVelocity;
-        // Do some sanity checking for the avatar. Make sure it's above ground and inbounds.
-        PositionSanityCheck(true);
+        // Avatars don't report their changes the usual way. Changes are checked for in the heartbeat loop.
+        // base.RequestPhysicsterseUpdate();
+
+        /*
+        DetailLog("{0},BSCharacter.UpdateProperties,call,pos={1},orient={2},vel={3},accel={4},rotVel={5}",
+                LocalID, entprop.Position, entprop.Rotation, entprop.Velocity, 
+                entprop.Acceleration, entprop.RotationalVelocity);
+         */
+    }
 
-        // remember the current and last set values
-        LastEntityProperties = CurrentEntityProperties;
-        CurrentEntityProperties = entprop;
+    // Called by the scene when a collision with this object is reported
+    // The collision, if it should be reported to the character, is placed in a collection
+    //   that will later be sent to the simulator when SendCollisions() is called.
+    CollisionEventUpdate collisionCollection = null;
+    public void Collide(uint collidingWith, ActorTypes type, Vector3 contactPoint, Vector3 contactNormal, float pentrationDepth)
+    {
+        // m_log.DebugFormat("{0}: Collide: ms={1}, id={2}, with={3}", LogHeader, _subscribedEventsMs, LocalID, collidingWith);
 
-        if (entprop.Velocity != LastEntityProperties.Velocity)
+        // The following makes IsColliding() and IsCollidingGround() work
+        _collidingStep = _scene.SimulationStep;
+        if (collidingWith == BSScene.TERRAIN_ID || collidingWith == BSScene.GROUNDPLANE_ID)
         {
-            // Changes in the velocity are suppressed in avatars.
-            // That's just the way they are defined.
-            OMV.Vector3 avVel = new OMV.Vector3(_appliedVelocity.X, _appliedVelocity.Y, entprop.Velocity.Z);
-            _velocity = avVel;
-            BulletSimAPI.SetLinearVelocity2(PhysBody.ptr, avVel);
+            _collidingGroundStep = _scene.SimulationStep;
         }
+        // DetailLog("{0},BSCharacter.Collison,call,with={1}", LocalID, collidingWith);
 
-        // Tell the linkset about value changes
-        Linkset.UpdateProperties(this);
+        // throttle collisions to the rate specified in the subscription
+        if (_subscribedEventsMs != 0) {
+            int nowTime = _scene.SimulationNowTime;
+            if (nowTime >= _nextCollisionOkTime) {
+                _nextCollisionOkTime = nowTime + _subscribedEventsMs;
 
-        // Avatars don't report their changes the usual way. Changes are checked for in the heartbeat loop.
-        // base.RequestPhysicsterseUpdate();
+                if (collisionCollection == null)
+                    collisionCollection = new CollisionEventUpdate();
+                collisionCollection.AddCollider(collidingWith, new ContactPoint(contactPoint, contactNormal, pentrationDepth));
+            }
+        }
+    }
 
-        DetailLog("{0},BSCharacter.UpdateProperties,call,pos={1},orient={2},vel={3},accel={4},rotVel={5}",
-                LocalID, _position, _orientation, _velocity, _acceleration, _rotationalVelocity);
+    public void SendCollisions()
+    {
+        /*
+        if (collisionCollection != null && collisionCollection.Count > 0)
+        {
+            base.SendCollisionUpdate(collisionCollection);
+            collisionCollection = null;
+        }
+         */
+        // Kludge to make a collision call even if there are no collisions.
+        // This causes the avatar animation to get updated.
+        if (collisionCollection == null)
+            collisionCollection = new CollisionEventUpdate();
+        base.SendCollisionUpdate(collisionCollection);
+        // If there were any collisions in the collection, make sure we don't use the
+        //    same instance next time.
+        if (collisionCollection.Count > 0)
+            collisionCollection = null;
+        // End kludge
+    }
+
+    // Invoke the detailed logger and output something if it's enabled.
+    private void DetailLog(string msg, params Object[] args)
+    {
+        Scene.PhysicsLogging.Write(msg, args);
     }
 }
 }
diff --git a/OpenSim/Region/Physics/BulletSPlugin/BSConstraint.cs b/OpenSim/Region/Physics/BulletSPlugin/BSConstraint.cs
index 65fac00..25084d8 100755
--- a/OpenSim/Region/Physics/BulletSPlugin/BSConstraint.cs
+++ b/OpenSim/Region/Physics/BulletSPlugin/BSConstraint.cs
@@ -34,20 +34,12 @@ namespace OpenSim.Region.Physics.BulletSPlugin
 
 public abstract class BSConstraint : IDisposable
 {
-    private static string LogHeader = "[BULLETSIM CONSTRAINT]";
-
     protected BulletSim m_world;
     protected BulletBody m_body1;
     protected BulletBody m_body2;
     protected BulletConstraint m_constraint;
     protected bool m_enabled = false;
 
-    public BulletBody Body1 { get { return m_body1; } }
-    public BulletBody Body2 { get { return m_body2; } }
-    public BulletConstraint Constraint { get { return m_constraint; } }
-    public abstract ConstraintType Type { get; }
-    public bool IsEnabled { get { return m_enabled; } }
-
     public BSConstraint()
     {
     }
@@ -56,25 +48,22 @@ public abstract class BSConstraint : IDisposable
     {
         if (m_enabled)
         {
+            // BulletSimAPI.RemoveConstraint(m_world.ID, m_body1.ID, m_body2.ID);
+            bool success = BulletSimAPI.DestroyConstraint2(m_world.Ptr, m_constraint.Ptr);
+            m_world.scene.DetailLog("{0},BSConstraint.Dispose,taint,body1={1},body2={2},success={3}", BSScene.DetailLogZero, m_body1.ID, m_body2.ID, success);
+            m_constraint.Ptr = System.IntPtr.Zero;
             m_enabled = false;
-            if (m_constraint.ptr != IntPtr.Zero)
-            {
-                bool success = BulletSimAPI.DestroyConstraint2(m_world.ptr, m_constraint.ptr);
-                m_world.physicsScene.DetailLog("{0},BSConstraint.Dispose,taint,id1={1},body1={2},id2={3},body2={4},success={5}",
-                                    BSScene.DetailLogZero,
-                                    m_body1.ID, m_body1.ptr.ToString("X"),
-                                    m_body2.ID, m_body2.ptr.ToString("X"),
-                                    success);
-                m_constraint.ptr = System.IntPtr.Zero;
-            }
         }
     }
 
+    public BulletBody Body1 { get { return m_body1; } }
+    public BulletBody Body2 { get { return m_body2; } }
+
     public virtual bool SetLinearLimits(Vector3 low, Vector3 high)
     {
         bool ret = false;
         if (m_enabled)
-            ret = BulletSimAPI.SetLinearLimits2(m_constraint.ptr, low, high);
+            ret = BulletSimAPI.SetLinearLimits2(m_constraint.Ptr, low, high);
         return ret;
     }
 
@@ -82,18 +71,7 @@ public abstract class BSConstraint : IDisposable
     {
         bool ret = false;
         if (m_enabled)
-            ret = BulletSimAPI.SetAngularLimits2(m_constraint.ptr, low, high);
-        return ret;
-    }
-
-    public virtual bool SetSolverIterations(float cnt)
-    {
-        bool ret = false;
-        if (m_enabled)
-        {
-            BulletSimAPI.SetConstraintNumSolverIterations2(m_constraint.ptr, cnt);
-            ret = true;
-        }
+            ret = BulletSimAPI.SetAngularLimits2(m_constraint.Ptr, low, high);
         return ret;
     }
 
@@ -103,7 +81,7 @@ public abstract class BSConstraint : IDisposable
         if (m_enabled)
         {
             // Recompute the internal transforms
-            BulletSimAPI.CalculateTransforms2(m_constraint.ptr);
+            BulletSimAPI.CalculateTransforms2(m_constraint.Ptr);
             ret = true;
         }
         return ret;
@@ -119,14 +97,13 @@ public abstract class BSConstraint : IDisposable
             ret = CalculateTransforms();
             if (ret)
             {
-                // Setting an object's mass to zero (making it static like when it's selected)
-                //     automatically disables the constraints.
-                // If the link is enabled, be sure to set the constraint itself to enabled.
-                BulletSimAPI.SetConstraintEnable2(m_constraint.ptr, m_world.physicsScene.NumericBool(true));
+                // m_world.scene.PhysicsLogging.Write("{0},BSConstraint.RecomputeConstraintVariables,taint,enabling,A={1},B={2}",
+                //                 BSScene.DetailLogZero, Body1.ID, Body2.ID);
+                BulletSimAPI.SetConstraintEnable2(m_constraint.Ptr, m_world.scene.NumericBool(true));
             }
             else
             {
-                m_world.physicsScene.Logger.ErrorFormat("{0} CalculateTransforms failed. A={1}, B={2}", LogHeader, Body1.ID, Body2.ID);
+                m_world.scene.Logger.ErrorFormat("[BULLETSIM CONSTRAINT] CalculateTransforms failed. A={0}, B={1}", Body1.ID, Body2.ID);
             }
         }
         return ret;
diff --git a/OpenSim/Region/Physics/BulletSPlugin/BSConstraintCollection.cs b/OpenSim/Region/Physics/BulletSPlugin/BSConstraintCollection.cs
index a9fd826..22ea367 100755
--- a/OpenSim/Region/Physics/BulletSPlugin/BSConstraintCollection.cs
+++ b/OpenSim/Region/Physics/BulletSPlugin/BSConstraintCollection.cs
@@ -33,7 +33,7 @@ using OpenMetaverse;
 namespace OpenSim.Region.Physics.BulletSPlugin
 {
 
-public sealed class BSConstraintCollection : IDisposable
+public class BSConstraintCollection : IDisposable
 {
     // private static readonly ILog m_log = LogManager.GetLogger(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType);
     // private static readonly string LogHeader = "[CONSTRAINT COLLECTION]";
@@ -143,6 +143,8 @@ public sealed class BSConstraintCollection : IDisposable
     // Return 'true' if any constraints were destroyed.
     public bool RemoveAndDestroyConstraint(BulletBody body1)
     {
+        // return BulletSimAPI.RemoveConstraintByID(m_world.ID, obj.ID);
+
         List<BSConstraint> toRemove = new List<BSConstraint>();
         uint lookingID = body1.ID;
         lock (m_constraints)
diff --git a/OpenSim/Region/Physics/BulletSPlugin/BSDynamics.cs b/OpenSim/Region/Physics/BulletSPlugin/BSDynamics.cs
index 819635a..5a9f135 100644
--- a/OpenSim/Region/Physics/BulletSPlugin/BSDynamics.cs
+++ b/OpenSim/Region/Physics/BulletSPlugin/BSDynamics.cs
@@ -23,7 +23,7 @@
  * 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.
- *
+ */
 
 /* RA: June 14, 2011. Copied from ODEDynamics.cs and converted to
  * call the BulletSim system.
@@ -52,15 +52,19 @@ using OpenSim.Region.Physics.Manager;
 
 namespace OpenSim.Region.Physics.BulletSPlugin
 {
-    public sealed class BSDynamics
+    public class BSDynamics
     {
-        private BSScene PhysicsScene { get; set; }
-        // the prim this dynamic controller belongs to
-        private BSPrim Prim { get; set; }
+        private int frcount = 0;                                        // Used to limit dynamics debug output to
+                                                                        // every 100th frame
 
-        // Vehicle properties
-        public Vehicle Type { get; set; }
+        private BSPrim m_prim;      // the prim this dynamic controller belongs to
 
+        // Vehicle properties
+        private Vehicle m_type = Vehicle.TYPE_NONE;                     // If a 'VEHICLE', and what kind
+        public Vehicle Type
+        {
+            get { return m_type; }
+        }
         // private Quaternion m_referenceFrame = Quaternion.Identity;   // Axis modifier
         private VehicleFlag m_flags = (VehicleFlag) 0;                  // Boolean settings:
                                                                         // HOVER_TERRAIN_ONLY
@@ -70,15 +74,13 @@ namespace OpenSim.Region.Physics.BulletSPlugin
                                                                         // HOVER_UP_ONLY
                                                                         // LIMIT_MOTOR_UP
                                                                         // LIMIT_ROLL_ONLY
+        private VehicleFlag m_Hoverflags = (VehicleFlag)0;
         private Vector3 m_BlockingEndPoint = Vector3.Zero;
         private Quaternion m_RollreferenceFrame = Quaternion.Identity;
-        private Quaternion m_referenceFrame = Quaternion.Identity;
-
         // Linear properties
         private Vector3 m_linearMotorDirection = Vector3.Zero;          // velocity requested by LSL, decayed by time
-        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_newVelocity = Vector3.Zero;                   // velocity computed to be applied to body
+        private Vector3 m_dir = Vector3.Zero;                           // velocity applied to body
         private Vector3 m_linearFrictionTimescale = Vector3.Zero;
         private float m_linearMotorDecayTimescale = 0;
         private float m_linearMotorTimescale = 0;
@@ -89,28 +91,28 @@ namespace OpenSim.Region.Physics.BulletSPlugin
 
         //Angular properties
         private Vector3 m_angularMotorDirection = Vector3.Zero;         // angular velocity requested by LSL motor
-        // private int m_angularMotorApply = 0;                            // application frame counter
+        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_angularMotorDecayTimescale = 0;                 // motor angular velocity decay rate
         private Vector3 m_angularFrictionTimescale = Vector3.Zero;      // body angular velocity  decay rate
         private Vector3 m_lastAngularVelocity = Vector3.Zero;           // what was last applied to body
-        private Vector3 m_lastVertAttractor = Vector3.Zero;             // what VA was last applied to body
+ //       private Vector3 m_lastVertAttractor = Vector3.Zero;             // what VA was last applied to body
 
         //Deflection properties
-        private float m_angularDeflectionEfficiency = 0;
-        private float m_angularDeflectionTimescale = 0;
-        private float m_linearDeflectionEfficiency = 0;
-        private float m_linearDeflectionTimescale = 0;
+        // private float m_angularDeflectionEfficiency = 0;
+        // private float m_angularDeflectionTimescale = 0;
+        // private float m_linearDeflectionEfficiency = 0;
+        // private float m_linearDeflectionTimescale = 0;
 
         //Banking properties
-        private float m_bankingEfficiency = 0;
-        private float m_bankingMix = 0;
-        private float m_bankingTimescale = 0;
+        // private float m_bankingEfficiency = 0;
+        // private float m_bankingMix = 0;
+        // private float m_bankingTimescale = 0;
 
         //Hover and Buoyancy properties
         private float m_VhoverHeight = 0f;
-        private float m_VhoverEfficiency = 0f;
+//        private float m_VhoverEfficiency = 0f;
         private float m_VhoverTimescale = 0f;
         private float m_VhoverTargetHeight = -1.0f;     // if <0 then no hover, else its the current target height
         private float m_VehicleBuoyancy = 0f;           //KF: m_VehicleBuoyancy is set by VEHICLE_BUOYANCY for a vehicle.
@@ -122,74 +124,86 @@ namespace OpenSim.Region.Physics.BulletSPlugin
         private float m_verticalAttractionEfficiency = 1.0f;        // damped
         private float m_verticalAttractionTimescale = 500f;         // Timescale > 300  means no vert attractor.
 
-        public BSDynamics(BSScene myScene, BSPrim myPrim)
-        {
-            PhysicsScene = myScene;
-            Prim = myPrim;
-            Type = Vehicle.TYPE_NONE;
-        }
-
-        // Return 'true' if this vehicle is doing vehicle things
-        public bool IsActive
+        public BSDynamics(BSPrim myPrim)
         {
-            get { return Type != Vehicle.TYPE_NONE; }
+            m_prim = myPrim;
+            m_type = Vehicle.TYPE_NONE;
         }
 
-        internal void ProcessFloatVehicleParam(Vehicle pParam, float pValue)
+        internal void ProcessFloatVehicleParam(Vehicle pParam, float pValue, float timestep)
         {
-            VDetailLog("{0},ProcessFloatVehicleParam,param={1},val={2}", Prim.LocalID, pParam, pValue);
+            DetailLog("{0},ProcessFloatVehicleParam,param={1},val={2}", m_prim.LocalID, pParam, pValue);
             switch (pParam)
             {
                 case Vehicle.ANGULAR_DEFLECTION_EFFICIENCY:
-                    m_angularDeflectionEfficiency = Math.Max(pValue, 0.01f);
+                    if (pValue < 0.01f) pValue = 0.01f;
+                    // m_angularDeflectionEfficiency = pValue;
                     break;
                 case Vehicle.ANGULAR_DEFLECTION_TIMESCALE:
-                    m_angularDeflectionTimescale = Math.Max(pValue, 0.01f);
+                    if (pValue < 0.01f) pValue = 0.01f;
+                    // m_angularDeflectionTimescale = pValue;
                     break;
                 case Vehicle.ANGULAR_MOTOR_DECAY_TIMESCALE:
-                    m_angularMotorDecayTimescale = Math.Max(pValue, 0.01f);
+                    if (pValue < 0.01f) pValue = 0.01f;
+                    m_angularMotorDecayTimescale = pValue;
                     break;
                 case Vehicle.ANGULAR_MOTOR_TIMESCALE:
-                    m_angularMotorTimescale = Math.Max(pValue, 0.01f);
+                    if (pValue < 0.01f) pValue = 0.01f;
+                    m_angularMotorTimescale = pValue;
                     break;
                 case Vehicle.BANKING_EFFICIENCY:
-                    m_bankingEfficiency = Math.Max(-1f, Math.Min(pValue, 1f));
+                    if (pValue < 0.01f) pValue = 0.01f;
+                    // m_bankingEfficiency = pValue;
                     break;
                 case Vehicle.BANKING_MIX:
-                    m_bankingMix = Math.Max(pValue, 0.01f);
+                    if (pValue < 0.01f) pValue = 0.01f;
+                    // m_bankingMix = pValue;
                     break;
                 case Vehicle.BANKING_TIMESCALE:
-                    m_bankingTimescale = Math.Max(pValue, 0.01f);
+                    if (pValue < 0.01f) pValue = 0.01f;
+                    // m_bankingTimescale = pValue;
                     break;
                 case Vehicle.BUOYANCY:
-                    m_VehicleBuoyancy = Math.Max(-1f, Math.Min(pValue, 1f));
-                    break;
-                case Vehicle.HOVER_EFFICIENCY:
-                    m_VhoverEfficiency = Math.Max(0f, Math.Min(pValue, 1f));
-                    break;
+                    if (pValue < -1f) pValue = -1f;
+                    if (pValue > 1f) pValue = 1f;
+                    m_VehicleBuoyancy = pValue;
+                    break;
+//                case Vehicle.HOVER_EFFICIENCY:
+//                    if (pValue < 0f) pValue = 0f;
+//                    if (pValue > 1f) pValue = 1f;
+//                    m_VhoverEfficiency = pValue;
+//                    break;
                 case Vehicle.HOVER_HEIGHT:
                     m_VhoverHeight = pValue;
                     break;
                 case Vehicle.HOVER_TIMESCALE:
-                    m_VhoverTimescale = Math.Max(pValue, 0.01f);
+                    if (pValue < 0.01f) pValue = 0.01f;
+                    m_VhoverTimescale = pValue;
                     break;
                 case Vehicle.LINEAR_DEFLECTION_EFFICIENCY:
-                    m_linearDeflectionEfficiency = Math.Max(pValue, 0.01f);
+                    if (pValue < 0.01f) pValue = 0.01f;
+                    // m_linearDeflectionEfficiency = pValue;
                     break;
                 case Vehicle.LINEAR_DEFLECTION_TIMESCALE:
-                    m_linearDeflectionTimescale = Math.Max(pValue, 0.01f);
+                    if (pValue < 0.01f) pValue = 0.01f;
+                    // m_linearDeflectionTimescale = pValue;
                     break;
                 case Vehicle.LINEAR_MOTOR_DECAY_TIMESCALE:
-                    m_linearMotorDecayTimescale = Math.Max(pValue, 0.01f);
+                    if (pValue < 0.01f) pValue = 0.01f;
+                    m_linearMotorDecayTimescale = pValue;
                     break;
                 case Vehicle.LINEAR_MOTOR_TIMESCALE:
-                    m_linearMotorTimescale = Math.Max(pValue, 0.01f);
+                    if (pValue < 0.01f) pValue = 0.01f;
+                    m_linearMotorTimescale = pValue;
                     break;
                 case Vehicle.VERTICAL_ATTRACTION_EFFICIENCY:
-                    m_verticalAttractionEfficiency = Math.Max(0.1f, Math.Min(pValue, 1f));
+                    if (pValue < 0.1f) pValue = 0.1f;    // Less goes unstable
+                    if (pValue > 1.0f) pValue = 1.0f;
+                    m_verticalAttractionEfficiency = pValue;
                     break;
                 case Vehicle.VERTICAL_ATTRACTION_TIMESCALE:
-                    m_verticalAttractionTimescale = Math.Max(pValue, 0.01f);
+                    if (pValue < 0.01f) pValue = 0.01f;
+                    m_verticalAttractionTimescale = pValue;
                     break;
 
                 // These are vector properties but the engine lets you use a single float value to
@@ -199,7 +213,7 @@ namespace OpenSim.Region.Physics.BulletSPlugin
                     break;
                 case Vehicle.ANGULAR_MOTOR_DIRECTION:
                     m_angularMotorDirection = new Vector3(pValue, pValue, pValue);
-                    // m_angularMotorApply = 100;
+                    m_angularMotorApply = 10;
                     break;
                 case Vehicle.LINEAR_FRICTION_TIMESCALE:
                     m_linearFrictionTimescale = new Vector3(pValue, pValue, pValue);
@@ -209,27 +223,30 @@ namespace OpenSim.Region.Physics.BulletSPlugin
                     m_linearMotorDirectionLASTSET = new Vector3(pValue, pValue, pValue);
                     break;
                 case Vehicle.LINEAR_MOTOR_OFFSET:
-                    m_linearMotorOffset = new Vector3(pValue, pValue, pValue);
+                    // m_linearMotorOffset = new Vector3(pValue, pValue, pValue);
                     break;
 
             }
         }//end ProcessFloatVehicleParam
 
-        internal void ProcessVectorVehicleParam(Vehicle pParam, Vector3 pValue)
+        internal void ProcessVectorVehicleParam(Vehicle pParam, Vector3 pValue, float timestep)
         {
-            VDetailLog("{0},ProcessVectorVehicleParam,param={1},val={2}", Prim.LocalID, pParam, pValue);
+            DetailLog("{0},ProcessVectorVehicleParam,param={1},val={2}", m_prim.LocalID, pParam, pValue);
             switch (pParam)
             {
                 case Vehicle.ANGULAR_FRICTION_TIMESCALE:
                     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 = Math.Max(-12.56f, Math.Min(pValue.X, 12.56f));
-                    pValue.Y = Math.Max(-12.56f, Math.Min(pValue.Y, 12.56f));
-                    pValue.Z = Math.Max(-12.56f, Math.Min(pValue.Z, 12.56f));
                     m_angularMotorDirection = new Vector3(pValue.X, pValue.Y, pValue.Z);
-                    // m_angularMotorApply = 100;
+                    // Limit requested angular speed to 2 rps= 4 pi rads/sec
+                    if (m_angularMotorDirection.X > 12.56f) m_angularMotorDirection.X = 12.56f;
+                    if (m_angularMotorDirection.X < - 12.56f) m_angularMotorDirection.X = - 12.56f;
+                    if (m_angularMotorDirection.Y > 12.56f) m_angularMotorDirection.Y = 12.56f;
+                    if (m_angularMotorDirection.Y < - 12.56f) m_angularMotorDirection.Y = - 12.56f;
+                    if (m_angularMotorDirection.Z > 12.56f) m_angularMotorDirection.Z = 12.56f;
+                    if (m_angularMotorDirection.Z < - 12.56f) m_angularMotorDirection.Z = - 12.56f;
+                    m_angularMotorApply = 10;
                     break;
                 case Vehicle.LINEAR_FRICTION_TIMESCALE:
                     m_linearFrictionTimescale = new Vector3(pValue.X, pValue.Y, pValue.Z);
@@ -239,7 +256,7 @@ namespace OpenSim.Region.Physics.BulletSPlugin
                     m_linearMotorDirectionLASTSET = new Vector3(pValue.X, pValue.Y, pValue.Z);
                     break;
                 case Vehicle.LINEAR_MOTOR_OFFSET:
-                    m_linearMotorOffset = new Vector3(pValue.X, pValue.Y, pValue.Z);
+                    // m_linearMotorOffset = new Vector3(pValue.X, pValue.Y, pValue.Z);
                     break;
                 case Vehicle.BLOCK_EXIT:
                     m_BlockingEndPoint = new Vector3(pValue.X, pValue.Y, pValue.Z);
@@ -249,11 +266,11 @@ namespace OpenSim.Region.Physics.BulletSPlugin
 
         internal void ProcessRotationVehicleParam(Vehicle pParam, Quaternion pValue)
         {
-            VDetailLog("{0},ProcessRotationalVehicleParam,param={1},val={2}", Prim.LocalID, pParam, pValue);
+            DetailLog("{0},ProcessRotationalVehicleParam,param={1},val={2}", m_prim.LocalID, pParam, pValue);
             switch (pParam)
             {
                 case Vehicle.REFERENCE_FRAME:
-                    m_referenceFrame = pValue;
+                    // m_referenceFrame = pValue;
                     break;
                 case Vehicle.ROLL_FRAME:
                     m_RollreferenceFrame = pValue;
@@ -263,492 +280,575 @@ namespace OpenSim.Region.Physics.BulletSPlugin
 
         internal void ProcessVehicleFlags(int pParam, bool remove)
         {
-            VDetailLog("{0},ProcessVehicleFlags,param={1},remove={2}", Prim.LocalID, pParam, remove);
-            VehicleFlag parm = (VehicleFlag)pParam;
-            if (pParam == -1)
-                m_flags = (VehicleFlag)0;
+            DetailLog("{0},ProcessVehicleFlags,param={1},remove={2}", m_prim.LocalID, pParam, remove);
+            if (remove)
+            {
+                if (pParam == -1)
+                {
+                    m_flags = (VehicleFlag)0;
+                    m_Hoverflags = (VehicleFlag)0;
+                    return;
+                }
+                if ((pParam & (int)VehicleFlag.HOVER_GLOBAL_HEIGHT) == (int)VehicleFlag.HOVER_GLOBAL_HEIGHT)
+                {
+                    if ((m_Hoverflags & VehicleFlag.HOVER_GLOBAL_HEIGHT) != (VehicleFlag)0)
+                        m_Hoverflags &= ~(VehicleFlag.HOVER_GLOBAL_HEIGHT);
+                }
+                if ((pParam & (int)VehicleFlag.HOVER_TERRAIN_ONLY) == (int)VehicleFlag.HOVER_TERRAIN_ONLY)
+                {
+                    if ((m_Hoverflags & VehicleFlag.HOVER_TERRAIN_ONLY) != (VehicleFlag)0)
+                        m_Hoverflags &= ~(VehicleFlag.HOVER_TERRAIN_ONLY);
+                }
+                if ((pParam & (int)VehicleFlag.HOVER_UP_ONLY) == (int)VehicleFlag.HOVER_UP_ONLY)
+                {
+                    if ((m_Hoverflags & VehicleFlag.HOVER_UP_ONLY) != (VehicleFlag)0)
+                        m_Hoverflags &= ~(VehicleFlag.HOVER_UP_ONLY);
+                }
+                if ((pParam & (int)VehicleFlag.HOVER_WATER_ONLY) == (int)VehicleFlag.HOVER_WATER_ONLY)
+                {
+                    if ((m_Hoverflags & VehicleFlag.HOVER_WATER_ONLY) != (VehicleFlag)0)
+                        m_Hoverflags &= ~(VehicleFlag.HOVER_WATER_ONLY);
+                }
+                if ((pParam & (int)VehicleFlag.LIMIT_MOTOR_UP) == (int)VehicleFlag.LIMIT_MOTOR_UP)
+                {
+                    if ((m_flags & VehicleFlag.LIMIT_MOTOR_UP) != (VehicleFlag)0)
+                        m_flags &= ~(VehicleFlag.LIMIT_MOTOR_UP);
+                }
+                if ((pParam & (int)VehicleFlag.LIMIT_ROLL_ONLY) == (int)VehicleFlag.LIMIT_ROLL_ONLY)
+                {
+                    if ((m_flags & VehicleFlag.LIMIT_ROLL_ONLY) != (VehicleFlag)0)
+                        m_flags &= ~(VehicleFlag.LIMIT_ROLL_ONLY);
+                }
+                if ((pParam & (int)VehicleFlag.MOUSELOOK_BANK) == (int)VehicleFlag.MOUSELOOK_BANK)
+                {
+                    if ((m_flags & VehicleFlag.MOUSELOOK_BANK) != (VehicleFlag)0)
+                        m_flags &= ~(VehicleFlag.MOUSELOOK_BANK);
+                }
+                if ((pParam & (int)VehicleFlag.MOUSELOOK_STEER) == (int)VehicleFlag.MOUSELOOK_STEER)
+                {
+                    if ((m_flags & VehicleFlag.MOUSELOOK_STEER) != (VehicleFlag)0)
+                        m_flags &= ~(VehicleFlag.MOUSELOOK_STEER);
+                }
+                if ((pParam & (int)VehicleFlag.NO_DEFLECTION_UP) == (int)VehicleFlag.NO_DEFLECTION_UP)
+                {
+                    if ((m_flags & VehicleFlag.NO_DEFLECTION_UP) != (VehicleFlag)0)
+                        m_flags &= ~(VehicleFlag.NO_DEFLECTION_UP);
+                }
+                if ((pParam & (int)VehicleFlag.CAMERA_DECOUPLED) == (int)VehicleFlag.CAMERA_DECOUPLED)
+                {
+                    if ((m_flags & VehicleFlag.CAMERA_DECOUPLED) != (VehicleFlag)0)
+                        m_flags &= ~(VehicleFlag.CAMERA_DECOUPLED);
+                }
+                if ((pParam & (int)VehicleFlag.NO_X) == (int)VehicleFlag.NO_X)
+                {
+                    if ((m_flags & VehicleFlag.NO_X) != (VehicleFlag)0)
+                        m_flags &= ~(VehicleFlag.NO_X);
+                }
+                if ((pParam & (int)VehicleFlag.NO_Y) == (int)VehicleFlag.NO_Y)
+                {
+                    if ((m_flags & VehicleFlag.NO_Y) != (VehicleFlag)0)
+                        m_flags &= ~(VehicleFlag.NO_Y);
+                }
+                if ((pParam & (int)VehicleFlag.NO_Z) == (int)VehicleFlag.NO_Z)
+                {
+                    if ((m_flags & VehicleFlag.NO_Z) != (VehicleFlag)0)
+                        m_flags &= ~(VehicleFlag.NO_Z);
+                }
+                if ((pParam & (int)VehicleFlag.LOCK_HOVER_HEIGHT) == (int)VehicleFlag.LOCK_HOVER_HEIGHT)
+                {
+                    if ((m_Hoverflags & VehicleFlag.LOCK_HOVER_HEIGHT) != (VehicleFlag)0)
+                        m_Hoverflags &= ~(VehicleFlag.LOCK_HOVER_HEIGHT);
+                }
+                if ((pParam & (int)VehicleFlag.NO_DEFLECTION) == (int)VehicleFlag.NO_DEFLECTION)
+                {
+                    if ((m_flags & VehicleFlag.NO_DEFLECTION) != (VehicleFlag)0)
+                        m_flags &= ~(VehicleFlag.NO_DEFLECTION);
+                }
+                if ((pParam & (int)VehicleFlag.LOCK_ROTATION) == (int)VehicleFlag.LOCK_ROTATION)
+                {
+                    if ((m_flags & VehicleFlag.LOCK_ROTATION) != (VehicleFlag)0)
+                        m_flags &= ~(VehicleFlag.LOCK_ROTATION);
+                }
+            }
             else
             {
-                if (remove)
-                    m_flags &= ~parm;
-                else
-                    m_flags |= parm;
+                if ((pParam & (int)VehicleFlag.HOVER_GLOBAL_HEIGHT) == (int)VehicleFlag.HOVER_GLOBAL_HEIGHT)
+                {
+                    m_Hoverflags |= (VehicleFlag.HOVER_GLOBAL_HEIGHT | m_flags);
+                }
+                if ((pParam & (int)VehicleFlag.HOVER_TERRAIN_ONLY) == (int)VehicleFlag.HOVER_TERRAIN_ONLY)
+                {
+                    m_Hoverflags |= (VehicleFlag.HOVER_TERRAIN_ONLY | m_flags);
+                }
+                if ((pParam & (int)VehicleFlag.HOVER_UP_ONLY) == (int)VehicleFlag.HOVER_UP_ONLY)
+                {
+                    m_Hoverflags |= (VehicleFlag.HOVER_UP_ONLY | m_flags);
+                }
+                if ((pParam & (int)VehicleFlag.HOVER_WATER_ONLY) == (int)VehicleFlag.HOVER_WATER_ONLY)
+                {
+                    m_Hoverflags |= (VehicleFlag.HOVER_WATER_ONLY | m_flags);
+                }
+                if ((pParam & (int)VehicleFlag.LIMIT_MOTOR_UP) == (int)VehicleFlag.LIMIT_MOTOR_UP)
+                {
+                    m_flags |= (VehicleFlag.LIMIT_MOTOR_UP | m_flags);
+                }
+                if ((pParam & (int)VehicleFlag.MOUSELOOK_BANK) == (int)VehicleFlag.MOUSELOOK_BANK)
+                {
+                    m_flags |= (VehicleFlag.MOUSELOOK_BANK | m_flags);
+                }
+                if ((pParam & (int)VehicleFlag.MOUSELOOK_STEER) == (int)VehicleFlag.MOUSELOOK_STEER)
+                {
+                    m_flags |= (VehicleFlag.MOUSELOOK_STEER | m_flags);
+                }
+                if ((pParam & (int)VehicleFlag.NO_DEFLECTION_UP) == (int)VehicleFlag.NO_DEFLECTION_UP)
+                {
+                    m_flags |= (VehicleFlag.NO_DEFLECTION_UP | m_flags);
+                }
+                if ((pParam & (int)VehicleFlag.CAMERA_DECOUPLED) == (int)VehicleFlag.CAMERA_DECOUPLED)
+                {
+                    m_flags |= (VehicleFlag.CAMERA_DECOUPLED | m_flags);
+                }
+                if ((pParam & (int)VehicleFlag.NO_X) == (int)VehicleFlag.NO_X)
+                {
+                    m_flags |= (VehicleFlag.NO_X);
+                }
+                if ((pParam & (int)VehicleFlag.NO_Y) == (int)VehicleFlag.NO_Y)
+                {
+                    m_flags |= (VehicleFlag.NO_Y);
+                }
+                if ((pParam & (int)VehicleFlag.NO_Z) == (int)VehicleFlag.NO_Z)
+                {
+                    m_flags |= (VehicleFlag.NO_Z);
+                }
+                if ((pParam & (int)VehicleFlag.LOCK_HOVER_HEIGHT) == (int)VehicleFlag.LOCK_HOVER_HEIGHT)
+                {
+                    m_Hoverflags |= (VehicleFlag.LOCK_HOVER_HEIGHT);
+                }
+                if ((pParam & (int)VehicleFlag.NO_DEFLECTION) == (int)VehicleFlag.NO_DEFLECTION)
+                {
+                    m_flags |= (VehicleFlag.NO_DEFLECTION);
+                }
+                if ((pParam & (int)VehicleFlag.LOCK_ROTATION) == (int)VehicleFlag.LOCK_ROTATION)
+                {
+                    m_flags |= (VehicleFlag.LOCK_ROTATION);
+                }
             }
-        }
+        }//end ProcessVehicleFlags
 
         internal void ProcessTypeChange(Vehicle pType)
         {
-            VDetailLog("{0},ProcessTypeChange,type={1}", Prim.LocalID, pType);
+            DetailLog("{0},ProcessTypeChange,type={1}", m_prim.LocalID, pType);
             // Set Defaults For Type
-            Type = pType;
+            m_type = pType;
             switch (pType)
             {
-                case Vehicle.TYPE_NONE:
+                    case Vehicle.TYPE_NONE:
+                    m_linearFrictionTimescale = new Vector3(0, 0, 0);
+                    m_angularFrictionTimescale = new Vector3(0, 0, 0);
                     m_linearMotorDirection = Vector3.Zero;
                     m_linearMotorTimescale = 0;
                     m_linearMotorDecayTimescale = 0;
-                    m_linearFrictionTimescale = new Vector3(0, 0, 0);
-
                     m_angularMotorDirection = Vector3.Zero;
-                    m_angularMotorDecayTimescale = 0;
                     m_angularMotorTimescale = 0;
-                    m_angularFrictionTimescale = new Vector3(0, 0, 0);
-
+                    m_angularMotorDecayTimescale = 0;
                     m_VhoverHeight = 0;
-                    m_VhoverEfficiency = 0;
                     m_VhoverTimescale = 0;
                     m_VehicleBuoyancy = 0;
-                    
-                    m_linearDeflectionEfficiency = 1;
-                    m_linearDeflectionTimescale = 1;
-
-                    m_angularDeflectionEfficiency = 0;
-                    m_angularDeflectionTimescale = 1000;
-
-                    m_verticalAttractionEfficiency = 0;
-                    m_verticalAttractionTimescale = 0;
-
-                    m_bankingEfficiency = 0;
-                    m_bankingTimescale = 1000;
-                    m_bankingMix = 1;
-
-                    m_referenceFrame = Quaternion.Identity;
                     m_flags = (VehicleFlag)0;
                     break;
 
                 case Vehicle.TYPE_SLED:
+                    m_linearFrictionTimescale = new Vector3(30, 1, 1000);
+                    m_angularFrictionTimescale = new Vector3(1000, 1000, 1000);
                     m_linearMotorDirection = Vector3.Zero;
                     m_linearMotorTimescale = 1000;
                     m_linearMotorDecayTimescale = 120;
-                    m_linearFrictionTimescale = new Vector3(30, 1, 1000);
-
                     m_angularMotorDirection = Vector3.Zero;
                     m_angularMotorTimescale = 1000;
                     m_angularMotorDecayTimescale = 120;
-                    m_angularFrictionTimescale = new Vector3(1000, 1000, 1000);
-
                     m_VhoverHeight = 0;
-                    m_VhoverEfficiency = 10;    // TODO: this looks wrong!!
+//                    m_VhoverEfficiency = 1;
                     m_VhoverTimescale = 10;
                     m_VehicleBuoyancy = 0;
-
-                    m_linearDeflectionEfficiency = 1;
-                    m_linearDeflectionTimescale = 1;
-
-                    m_angularDeflectionEfficiency = 1;
-                    m_angularDeflectionTimescale = 1000;
-
-                    m_verticalAttractionEfficiency = 0;
-                    m_verticalAttractionTimescale = 0;
-
-                    m_bankingEfficiency = 0;
-                    m_bankingTimescale = 10;
-                    m_bankingMix = 1;
-
-                    m_referenceFrame = Quaternion.Identity;
-                    m_flags |= (VehicleFlag.NO_DEFLECTION_UP | VehicleFlag.LIMIT_ROLL_ONLY | VehicleFlag.LIMIT_MOTOR_UP);
-                    m_flags &=
+                    // m_linearDeflectionEfficiency = 1;
+                    // m_linearDeflectionTimescale = 1;
+                    // m_angularDeflectionEfficiency = 1;
+                    // m_angularDeflectionTimescale = 1000;
+                    // m_bankingEfficiency = 0;
+                    // m_bankingMix = 1;
+                    // m_bankingTimescale = 10;
+                    // m_referenceFrame = Quaternion.Identity;
+                    m_Hoverflags &=
                          ~(VehicleFlag.HOVER_WATER_ONLY | VehicleFlag.HOVER_TERRAIN_ONLY |
                            VehicleFlag.HOVER_GLOBAL_HEIGHT | VehicleFlag.HOVER_UP_ONLY);
+                    m_flags |= (VehicleFlag.NO_DEFLECTION_UP | VehicleFlag.LIMIT_ROLL_ONLY | VehicleFlag.LIMIT_MOTOR_UP);
                     break;
                 case Vehicle.TYPE_CAR:
+                    m_linearFrictionTimescale = new Vector3(100, 2, 1000);
+                    m_angularFrictionTimescale = new Vector3(1000, 1000, 1000);
                     m_linearMotorDirection = Vector3.Zero;
                     m_linearMotorTimescale = 1;
                     m_linearMotorDecayTimescale = 60;
-                    m_linearFrictionTimescale = new Vector3(100, 2, 1000);
-
                     m_angularMotorDirection = Vector3.Zero;
                     m_angularMotorTimescale = 1;
                     m_angularMotorDecayTimescale = 0.8f;
-                    m_angularFrictionTimescale = new Vector3(1000, 1000, 1000);
-
                     m_VhoverHeight = 0;
-                    m_VhoverEfficiency = 0;
+//                    m_VhoverEfficiency = 0;
                     m_VhoverTimescale = 1000;
                     m_VehicleBuoyancy = 0;
-
-                    m_linearDeflectionEfficiency = 1;
-                    m_linearDeflectionTimescale = 2;
-
-                    m_angularDeflectionEfficiency = 0;
-                    m_angularDeflectionTimescale = 10;
-
+                    // // m_linearDeflectionEfficiency = 1;
+                    // // m_linearDeflectionTimescale = 2;
+                    // // m_angularDeflectionEfficiency = 0;
+                    // m_angularDeflectionTimescale = 10;
                     m_verticalAttractionEfficiency = 1f;
                     m_verticalAttractionTimescale = 10f;
-
-                    m_bankingEfficiency = -0.2f;
-                    m_bankingMix = 1;
-                    m_bankingTimescale = 1;
-
-                    m_referenceFrame = Quaternion.Identity;
-                    m_flags &= ~(VehicleFlag.HOVER_WATER_ONLY
-                                | VehicleFlag.HOVER_TERRAIN_ONLY
-                                | VehicleFlag.HOVER_GLOBAL_HEIGHT);
-                    m_flags |= (VehicleFlag.NO_DEFLECTION_UP
-                                | VehicleFlag.LIMIT_ROLL_ONLY
-                                | VehicleFlag.LIMIT_MOTOR_UP
-                                | VehicleFlag.HOVER_UP_ONLY);
+                    // m_bankingEfficiency = -0.2f;
+                    // m_bankingMix = 1;
+                    // m_bankingTimescale = 1;
+                    // m_referenceFrame = Quaternion.Identity;
+                    m_Hoverflags &= ~(VehicleFlag.HOVER_WATER_ONLY | VehicleFlag.HOVER_TERRAIN_ONLY | VehicleFlag.HOVER_GLOBAL_HEIGHT);
+                    m_flags |= (VehicleFlag.NO_DEFLECTION_UP | VehicleFlag.LIMIT_ROLL_ONLY |
+                                VehicleFlag.LIMIT_MOTOR_UP);
+                    m_Hoverflags |= (VehicleFlag.HOVER_UP_ONLY);
                     break;
                 case Vehicle.TYPE_BOAT:
+                    m_linearFrictionTimescale = new Vector3(10, 3, 2);
+                    m_angularFrictionTimescale = new Vector3(10,10,10);
                     m_linearMotorDirection = Vector3.Zero;
                     m_linearMotorTimescale = 5;
                     m_linearMotorDecayTimescale = 60;
-                    m_linearFrictionTimescale = new Vector3(10, 3, 2);
-
                     m_angularMotorDirection = Vector3.Zero;
                     m_angularMotorTimescale = 4;
                     m_angularMotorDecayTimescale = 4;
-                    m_angularFrictionTimescale = new Vector3(10,10,10);
-
                     m_VhoverHeight = 0;
-                    m_VhoverEfficiency = 0.5f;
+//                    m_VhoverEfficiency = 0.5f;
                     m_VhoverTimescale = 2;
                     m_VehicleBuoyancy = 1;
-
-                    m_linearDeflectionEfficiency = 0.5f;
-                    m_linearDeflectionTimescale = 3;
-
-                    m_angularDeflectionEfficiency = 0.5f;
-                    m_angularDeflectionTimescale = 5;
-
+                    // m_linearDeflectionEfficiency = 0.5f;
+                    // m_linearDeflectionTimescale = 3;
+                    // m_angularDeflectionEfficiency = 0.5f;
+                    // m_angularDeflectionTimescale = 5;
                     m_verticalAttractionEfficiency = 0.5f;
                     m_verticalAttractionTimescale = 5f;
-
-                    m_bankingEfficiency = -0.3f;
-                    m_bankingMix = 0.8f;
-                    m_bankingTimescale = 1;
-
-                    m_referenceFrame = Quaternion.Identity;
-                    m_flags &= ~(VehicleFlag.HOVER_TERRAIN_ONLY
-                                    | VehicleFlag.HOVER_GLOBAL_HEIGHT
-                                    | VehicleFlag.LIMIT_ROLL_ONLY
-                                    | VehicleFlag.HOVER_UP_ONLY);
-                    m_flags |= (VehicleFlag.NO_DEFLECTION_UP
-                                    | VehicleFlag.LIMIT_MOTOR_UP
-                                    | VehicleFlag.HOVER_WATER_ONLY);
+                    // m_bankingEfficiency = -0.3f;
+                    // m_bankingMix = 0.8f;
+                    // m_bankingTimescale = 1;
+                    // m_referenceFrame = Quaternion.Identity;
+                    m_Hoverflags &= ~(VehicleFlag.HOVER_TERRAIN_ONLY |
+                            VehicleFlag.HOVER_GLOBAL_HEIGHT | VehicleFlag.HOVER_UP_ONLY);
+                    m_flags &= ~(VehicleFlag.LIMIT_ROLL_ONLY);
+                    m_flags |= (VehicleFlag.NO_DEFLECTION_UP |
+                                VehicleFlag.LIMIT_MOTOR_UP);
+                    m_Hoverflags |= (VehicleFlag.HOVER_WATER_ONLY);
                     break;
                 case Vehicle.TYPE_AIRPLANE:
+                    m_linearFrictionTimescale = new Vector3(200, 10, 5);
+                    m_angularFrictionTimescale = new Vector3(20, 20, 20);
                     m_linearMotorDirection = Vector3.Zero;
                     m_linearMotorTimescale = 2;
                     m_linearMotorDecayTimescale = 60;
-                    m_linearFrictionTimescale = new Vector3(200, 10, 5);
-
                     m_angularMotorDirection = Vector3.Zero;
                     m_angularMotorTimescale = 4;
                     m_angularMotorDecayTimescale = 4;
-                    m_angularFrictionTimescale = new Vector3(20, 20, 20);
-
                     m_VhoverHeight = 0;
-                    m_VhoverEfficiency = 0.5f;
+//                    m_VhoverEfficiency = 0.5f;
                     m_VhoverTimescale = 1000;
                     m_VehicleBuoyancy = 0;
-
-                    m_linearDeflectionEfficiency = 0.5f;
-                    m_linearDeflectionTimescale = 3;
-
-                    m_angularDeflectionEfficiency = 1;
-                    m_angularDeflectionTimescale = 2;
-
+                    // m_linearDeflectionEfficiency = 0.5f;
+                    // m_linearDeflectionTimescale = 3;
+                    // m_angularDeflectionEfficiency = 1;
+                    // m_angularDeflectionTimescale = 2;
                     m_verticalAttractionEfficiency = 0.9f;
                     m_verticalAttractionTimescale = 2f;
-
-                    m_bankingEfficiency = 1;
-                    m_bankingMix = 0.7f;
-                    m_bankingTimescale = 2;
-
-                    m_referenceFrame = Quaternion.Identity;
-                    m_flags &= ~(VehicleFlag.HOVER_WATER_ONLY
-                                    | VehicleFlag.HOVER_TERRAIN_ONLY
-                                    | VehicleFlag.HOVER_GLOBAL_HEIGHT
-                                    | VehicleFlag.HOVER_UP_ONLY
-                                    | VehicleFlag.NO_DEFLECTION_UP
-                                    | VehicleFlag.LIMIT_MOTOR_UP);
+                    // m_bankingEfficiency = 1;
+                    // m_bankingMix = 0.7f;
+                    // m_bankingTimescale = 2;
+                    // m_referenceFrame = Quaternion.Identity;
+                    m_Hoverflags &= ~(VehicleFlag.HOVER_WATER_ONLY | VehicleFlag.HOVER_TERRAIN_ONLY |
+                        VehicleFlag.HOVER_GLOBAL_HEIGHT | VehicleFlag.HOVER_UP_ONLY);
+                    m_flags &= ~(VehicleFlag.NO_DEFLECTION_UP | VehicleFlag.LIMIT_MOTOR_UP);
                     m_flags |= (VehicleFlag.LIMIT_ROLL_ONLY);
                     break;
                 case Vehicle.TYPE_BALLOON:
+                    m_linearFrictionTimescale = new Vector3(5, 5, 5);
+                    m_angularFrictionTimescale = new Vector3(10, 10, 10);
                     m_linearMotorDirection = Vector3.Zero;
                     m_linearMotorTimescale = 5;
-                    m_linearFrictionTimescale = new Vector3(5, 5, 5);
                     m_linearMotorDecayTimescale = 60;
-
                     m_angularMotorDirection = Vector3.Zero;
                     m_angularMotorTimescale = 6;
-                    m_angularFrictionTimescale = new Vector3(10, 10, 10);
                     m_angularMotorDecayTimescale = 10;
-
                     m_VhoverHeight = 5;
-                    m_VhoverEfficiency = 0.8f;
+//                    m_VhoverEfficiency = 0.8f;
                     m_VhoverTimescale = 10;
                     m_VehicleBuoyancy = 1;
-
-                    m_linearDeflectionEfficiency = 0;
-                    m_linearDeflectionTimescale = 5;
-
-                    m_angularDeflectionEfficiency = 0;
-                    m_angularDeflectionTimescale = 5;
-
+                    // m_linearDeflectionEfficiency = 0;
+                    // m_linearDeflectionTimescale = 5;
+                    // m_angularDeflectionEfficiency = 0;
+                    // m_angularDeflectionTimescale = 5;
                     m_verticalAttractionEfficiency = 1f;
                     m_verticalAttractionTimescale = 100f;
-
-                    m_bankingEfficiency = 0;
-                    m_bankingMix = 0.7f;
-                    m_bankingTimescale = 5;
-                    m_referenceFrame = Quaternion.Identity;
-
-                    m_referenceFrame = Quaternion.Identity;
-                    m_flags &= ~(VehicleFlag.HOVER_WATER_ONLY
-                                    | VehicleFlag.HOVER_TERRAIN_ONLY
-                                    | VehicleFlag.HOVER_UP_ONLY
-                                    | VehicleFlag.NO_DEFLECTION_UP
-                                    | VehicleFlag.LIMIT_MOTOR_UP);
-                    m_flags |= (VehicleFlag.LIMIT_ROLL_ONLY
-                                    | VehicleFlag.HOVER_GLOBAL_HEIGHT);
+                    // m_bankingEfficiency = 0;
+                    // m_bankingMix = 0.7f;
+                    // m_bankingTimescale = 5;
+                    // m_referenceFrame = Quaternion.Identity;
+                    m_Hoverflags &= ~(VehicleFlag.HOVER_WATER_ONLY | VehicleFlag.HOVER_TERRAIN_ONLY |
+                        VehicleFlag.HOVER_UP_ONLY);
+                    m_flags &= ~(VehicleFlag.NO_DEFLECTION_UP | VehicleFlag.LIMIT_MOTOR_UP);
+                    m_flags |= (VehicleFlag.LIMIT_ROLL_ONLY);
+                    m_Hoverflags |= (VehicleFlag.HOVER_GLOBAL_HEIGHT);
                     break;
             }
-        }
+        }//end SetDefaultsForType
 
-        // Some of the properties of this prim may have changed.
-        // Do any updating needed for a vehicle
-        public void Refresh()
-        {
-            if (IsActive)
-            {
-                // Friction effects are handled by this vehicle code
-                BulletSimAPI.SetFriction2(Prim.PhysBody.ptr, 0f);
-                BulletSimAPI.SetHitFraction2(Prim.PhysBody.ptr, 0f);
-            }
-        }
-
-        // One step of the vehicle properties for the next 'pTimestep' seconds.
         internal void Step(float pTimestep)
         {
-            if (!IsActive) return;
+            if (m_type == Vehicle.TYPE_NONE) return;
 
-            // DEBUG
-            // Because Bullet does apply forces to the vehicle, our last computed
-            //     linear and angular velocities are not what is happening now.
-            // Vector3 externalAngularVelocity = Prim.ForceRotationalVelocity - m_lastAngularVelocity;
-            // m_lastAngularVelocity += (externalAngularVelocity * 0.5f) * pTimestep;
-            // m_lastAngularVelocity = Prim.ForceRotationalVelocity;   // DEBUG: account for what Bullet did last time
-            // m_lastLinearVelocityVector = Prim.ForceVelocity * Quaternion.Inverse(Prim.ForceOrientation);        // DEBUG:
-            // END DEBUG
+            frcount++;  // used to limit debug comment output
+            if (frcount > 100)
+                frcount = 0;
 
             MoveLinear(pTimestep);
             MoveAngular(pTimestep);
             LimitRotation(pTimestep);
 
-            // DEBUG: Trying to figure out why Bullet goes crazy when the root prim is moved.
-            // BulletSimAPI.SetInterpolationVelocity2(Prim.BSBody.ptr, m_newVelocity, m_lastAngularVelocity); // DEBUG DEBUG DEBUG
-
-            // remember the position so next step we can limit absolute movement effects
-            m_lastPositionVector = Prim.ForcePosition;
-
-            VDetailLog("{0},BSDynamics.Step,done,pos={1},force={2},velocity={3},angvel={4}",
-                    Prim.LocalID, Prim.ForcePosition, Prim.Force, Prim.ForceVelocity, Prim.RotationalVelocity);
+            DetailLog("{0},BSDynamics.Step,done,pos={1},force={2},velocity={3},angvel={4}", 
+                    m_prim.LocalID, m_prim.Position, m_prim.Force, m_prim.Velocity, m_prim.RotationalVelocity);
         }// end Step
 
-        // Apply the effect of the linear motor.
-        // Also does hover and float.
         private void MoveLinear(float pTimestep)
         {
-            // m_linearMotorDirection is the target direction we are moving relative to the vehicle coordinates
-            // m_lastLinearVelocityVector is the current speed we are moving in that direction
-            if (m_linearMotorDirection.LengthSquared() > 0.001f)
+            // requested m_linearMotorDirection is significant
+            // if (!m_linearMotorDirection.ApproxEquals(Vector3.Zero, 0.01f))
+            if (m_linearMotorDirection.LengthSquared() > 0.0001f)
             {
                 Vector3 origDir = m_linearMotorDirection;
                 Vector3 origVel = m_lastLinearVelocityVector;
-                Vector3 vehicleVelocity = Prim.ForceVelocity * Quaternion.Inverse(Prim.ForceOrientation);   // DEBUG
 
                 // add drive to body
-                Vector3 addAmount = (m_linearMotorDirection - m_lastLinearVelocityVector)/(m_linearMotorTimescale) * pTimestep;
-                // lastLinearVelocityVector is the current body velocity vector
+                // Vector3 addAmount = m_linearMotorDirection/(m_linearMotorTimescale/pTimestep);
+                Vector3 addAmount = m_linearMotorDirection/(m_linearMotorTimescale);
+                // lastLinearVelocityVector is the current body velocity vector?
+                // RA: Not sure what the *10 is for. A correction for pTimestep?
+                // m_lastLinearVelocityVector += (addAmount*10);  
+                m_lastLinearVelocityVector += addAmount;  
+
+                // This will work temporarily, but we really need to compare speed on an axis
+                // KF: Limit body velocity to applied velocity?
+                // Limit the velocity vector to less than the last set linear motor direction
+                if (Math.Abs(m_lastLinearVelocityVector.X) > Math.Abs(m_linearMotorDirectionLASTSET.X))
+                    m_lastLinearVelocityVector.X = m_linearMotorDirectionLASTSET.X;
+                if (Math.Abs(m_lastLinearVelocityVector.Y) > Math.Abs(m_linearMotorDirectionLASTSET.Y))
+                    m_lastLinearVelocityVector.Y = m_linearMotorDirectionLASTSET.Y;
+                if (Math.Abs(m_lastLinearVelocityVector.Z) > Math.Abs(m_linearMotorDirectionLASTSET.Z))
+                    m_lastLinearVelocityVector.Z = m_linearMotorDirectionLASTSET.Z;
+
+                // decay applied velocity
+                Vector3 decayfraction = ((Vector3.One/(m_linearMotorDecayTimescale/pTimestep)));
+                m_linearMotorDirection -= m_linearMotorDirection * decayfraction * 0.5f;
+
+                /*
+                Vector3 addAmount = (m_linearMotorDirection - m_lastLinearVelocityVector)/m_linearMotorTimescale;
                 m_lastLinearVelocityVector += addAmount;
 
-                float decayFactor = (1.0f / m_linearMotorDecayTimescale) * pTimestep;
-                m_linearMotorDirection *= (1f - decayFactor);
+                float decayfraction = (1.0f - 1.0f / m_linearMotorDecayTimescale);
+                m_linearMotorDirection *= decayfraction;
 
-                Vector3 frictionFactor = (Vector3.One / m_linearFrictionTimescale) * pTimestep;
-                m_lastLinearVelocityVector *= (Vector3.One - frictionFactor);
+                 */
 
-                // Rotate new object velocity from vehicle relative to world coordinates
-                m_newVelocity = m_lastLinearVelocityVector * Prim.ForceOrientation;
-
-                VDetailLog("{0},MoveLinear,nonZero,origdir={1},origvel={2},vehVel={3},add={4},decay={5},frict={6},lmDir={7},lmVel={8},newVel={9}",
-                                Prim.LocalID, origDir, origVel, vehicleVelocity, addAmount, decayFactor, frictionFactor, 
-                                m_linearMotorDirection, m_lastLinearVelocityVector, m_newVelocity);
+                DetailLog("{0},MoveLinear,nonZero,origdir={1},origvel={2},add={3},decay={4},dir={5},vel={6}",
+                    m_prim.LocalID, origDir, origVel, addAmount, decayfraction, m_linearMotorDirection, m_lastLinearVelocityVector);
             }
             else
             {
-                // if what remains of direction is very small, zero it.
+                // if what remains of applied is small, zero it.
+                // if (m_lastLinearVelocityVector.ApproxEquals(Vector3.Zero, 0.01f))
+                //     m_lastLinearVelocityVector = Vector3.Zero;
                 m_linearMotorDirection = Vector3.Zero;
                 m_lastLinearVelocityVector = Vector3.Zero;
-                m_newVelocity = Vector3.Zero;
-
-                VDetailLog("{0},MoveLinear,zeroed", Prim.LocalID);
             }
 
-            // m_newVelocity is velocity computed from linear motor in world coordinates
+            // convert requested object velocity to world-referenced vector
+            Quaternion rotq = m_prim.Orientation;
+            m_dir = m_lastLinearVelocityVector * rotq;
 
-            // Gravity and Buoyancy
+            // Add the various forces into m_dir which will be our new direction vector (velocity)
+
+            // add Gravity and Buoyancy
+            // KF: So far I have found no good method to combine a script-requested
+            // .Z velocity and gravity. Therefore only 0g will used script-requested
+            // .Z velocity. >0g (m_VehicleBuoyancy < 1) will used modified gravity only.
+            Vector3 grav = Vector3.Zero;
             // There is some gravity, make a gravity force vector that is applied after object velocity.
             // m_VehicleBuoyancy: -1=2g; 0=1g; 1=0g;
-            Vector3 grav = Prim.PhysicsScene.DefaultGravity * (1f - m_VehicleBuoyancy);
-
-            /*
-             * RA: Not sure why one would do this unless we are hoping external forces are doing gravity, ...
+            grav.Z = m_prim.Scene.DefaultGravity.Z * m_prim.Mass * (1f - m_VehicleBuoyancy);
             // Preserve the current Z velocity
             Vector3 vel_now = m_prim.Velocity;
             m_dir.Z = vel_now.Z;        // Preserve the accumulated falling velocity
-             */
 
-            Vector3 pos = Prim.ForcePosition;
+            Vector3 pos = m_prim.Position;
+            Vector3 posChange = pos;
 //            Vector3 accel = new Vector3(-(m_dir.X - m_lastLinearVelocityVector.X / 0.1f), -(m_dir.Y - m_lastLinearVelocityVector.Y / 0.1f), m_dir.Z - m_lastLinearVelocityVector.Z / 0.1f);
+            double Zchange = Math.Abs(posChange.Z);
+            if (m_BlockingEndPoint != Vector3.Zero)
+            {
+                bool changed = false;
+                if (pos.X >= (m_BlockingEndPoint.X - (float)1))
+                {
+                    pos.X -= posChange.X + 1;
+                    changed = true;
+                }
+                if (pos.Y >= (m_BlockingEndPoint.Y - (float)1))
+                {
+                    pos.Y -= posChange.Y + 1;
+                    changed = true;
+                }
+                if (pos.Z >= (m_BlockingEndPoint.Z - (float)1))
+                {
+                    pos.Z -= posChange.Z + 1;
+                    changed = true;
+                }
+                if (pos.X <= 0)
+                {
+                    pos.X += posChange.X + 1;
+                    changed = true;
+                }
+                if (pos.Y <= 0)
+                {
+                    pos.Y += posChange.Y + 1;
+                    changed = true;
+                }
+                if (changed)
+                {
+                    m_prim.Position = pos;
+                    DetailLog("{0},MoveLinear,blockingEndPoint,block={1},origPos={2},pos={3}",
+                                m_prim.LocalID, m_BlockingEndPoint, posChange, pos);
+                }
+            }
 
             // If below the terrain, move us above the ground a little.
-            float terrainHeight = Prim.PhysicsScene.TerrainManager.GetTerrainHeightAtXYZ(pos);
-            // Taking the rotated size doesn't work here because m_prim.Size is the size of the root prim and not the linkset.
-            //     Need to add a m_prim.LinkSet.Size similar to m_prim.LinkSet.Mass.
-            // Vector3 rotatedSize = m_prim.Size * m_prim.ForceOrientation;
-            // if (rotatedSize.Z < terrainHeight)
-            if (pos.Z < terrainHeight)
+            if (pos.Z < m_prim.Scene.GetTerrainHeightAtXYZ(pos))
             {
-                pos.Z = terrainHeight + 2;
-                Prim.ForcePosition = pos;
-                VDetailLog("{0},MoveLinear,terrainHeight,terrainHeight={1},pos={2}", Prim.LocalID, terrainHeight, pos);
+                pos.Z = m_prim.Scene.GetTerrainHeightAtXYZ(pos) + 2;
+                m_prim.Position = pos;
+                DetailLog("{0},MoveLinear,terrainHeight,pos={1}", m_prim.LocalID, pos);
             }
 
             // Check if hovering
-            // 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_Hoverflags & (VehicleFlag.HOVER_WATER_ONLY | VehicleFlag.HOVER_TERRAIN_ONLY | VehicleFlag.HOVER_GLOBAL_HEIGHT)) != 0)
             {
                 // We should hover, get the target height
-                if ((m_flags & VehicleFlag.HOVER_WATER_ONLY) != 0)
+                if ((m_Hoverflags & VehicleFlag.HOVER_WATER_ONLY) != 0)
                 {
-                    m_VhoverTargetHeight = Prim.PhysicsScene.GetWaterLevelAtXYZ(pos) + m_VhoverHeight;
+                    m_VhoverTargetHeight = m_prim.Scene.GetWaterLevel() + m_VhoverHeight;
                 }
-                if ((m_flags & VehicleFlag.HOVER_TERRAIN_ONLY) != 0)
+                if ((m_Hoverflags & VehicleFlag.HOVER_TERRAIN_ONLY) != 0)
                 {
-                    m_VhoverTargetHeight = terrainHeight + m_VhoverHeight;
+                    m_VhoverTargetHeight = m_prim.Scene.GetTerrainHeightAtXY(pos.X, pos.Y) + m_VhoverHeight;
                 }
-                if ((m_flags & VehicleFlag.HOVER_GLOBAL_HEIGHT) != 0)
+                if ((m_Hoverflags & VehicleFlag.HOVER_GLOBAL_HEIGHT) != 0)
                 {
                     m_VhoverTargetHeight = m_VhoverHeight;
                 }
 
-                if ((m_flags & VehicleFlag.HOVER_UP_ONLY) != 0)
+                if ((m_Hoverflags & VehicleFlag.HOVER_UP_ONLY) != 0)
                 {
                     // If body is aready heigher, use its height as target height
                     if (pos.Z > m_VhoverTargetHeight) m_VhoverTargetHeight = pos.Z;
                 }
-                if ((m_flags & VehicleFlag.LOCK_HOVER_HEIGHT) != 0)
+                if ((m_Hoverflags & VehicleFlag.LOCK_HOVER_HEIGHT) != 0)
                 {
                     if ((pos.Z - m_VhoverTargetHeight) > .2 || (pos.Z - m_VhoverTargetHeight) < -.2)
                     {
-                        Prim.ForcePosition = pos;
+                        m_prim.Position = pos;
                     }
                 }
                 else
                 {
-                    float verticalError = pos.Z - m_VhoverTargetHeight;
-                    // RA: where does the 50 come from?
-                    float verticalCorrectionVelocity = pTimestep * ((verticalError * 50.0f) / m_VhoverTimescale);
+                    float herr0 = pos.Z - m_VhoverTargetHeight;
                     // Replace Vertical speed with correction figure if significant
-                    if (Math.Abs(verticalError) > 0.01f)
+                    if (Math.Abs(herr0) > 0.01f)
                     {
-                        m_newVelocity.Z += verticalCorrectionVelocity;
+                        m_dir.Z = -((herr0 * pTimestep * 50.0f) / m_VhoverTimescale);
                         //KF: m_VhoverEfficiency is not yet implemented
                     }
-                    else if (verticalError < -0.01)
-                    {
-                        m_newVelocity.Z -= verticalCorrectionVelocity;
-                    }
                     else
                     {
-                        m_newVelocity.Z = 0f;
+                        m_dir.Z = 0f;
                     }
                 }
 
-                VDetailLog("{0},MoveLinear,hover,pos={1},dir={2},height={3},target={4}", Prim.LocalID, pos, m_newVelocity, m_VhoverHeight, m_VhoverTargetHeight);
-            }
+                DetailLog("{0},MoveLinear,hover,pos={1},dir={2},height={3},target={4}", m_prim.LocalID, pos, m_dir, m_VhoverHeight, m_VhoverTargetHeight);
 
-            Vector3 posChange = pos - m_lastPositionVector;
-            if (m_BlockingEndPoint != Vector3.Zero)
-            {
-                bool changed = false;
-                if (pos.X >= (m_BlockingEndPoint.X - (float)1))
-                {
-                    pos.X -= posChange.X + 1;
-                    changed = true;
-                }
-                if (pos.Y >= (m_BlockingEndPoint.Y - (float)1))
-                {
-                    pos.Y -= posChange.Y + 1;
-                    changed = true;
-                }
-                if (pos.Z >= (m_BlockingEndPoint.Z - (float)1))
-                {
-                    pos.Z -= posChange.Z + 1;
-                    changed = true;
-                }
-                if (pos.X <= 0)
-                {
-                    pos.X += posChange.X + 1;
-                    changed = true;
-                }
-                if (pos.Y <= 0)
-                {
-                    pos.Y += posChange.Y + 1;
-                    changed = true;
-                }
-                if (changed)
-                {
-                    Prim.ForcePosition = pos;
-                    VDetailLog("{0},MoveLinear,blockingEndPoint,block={1},origPos={2},pos={3}",
-                                Prim.LocalID, m_BlockingEndPoint, posChange, pos);
-                }
+//                m_VhoverEfficiency = 0f;    // 0=boucy, 1=Crit.damped
+//                m_VhoverTimescale = 0f;        // time to acheive height
+//                pTimestep  is time since last frame,in secs
             }
 
-            // Limit absolute vertical change
-            float Zchange = Math.Abs(posChange.Z);
             if ((m_flags & (VehicleFlag.LIMIT_MOTOR_UP)) != 0)
             {
+                //Start Experimental Values
                 if (Zchange > .3)
+                {
                     grav.Z = (float)(grav.Z * 3);
+                }
                 if (Zchange > .15)
+                {
                     grav.Z = (float)(grav.Z * 2);
+                }
                 if (Zchange > .75)
+                {
                     grav.Z = (float)(grav.Z * 1.5);
+                }
                 if (Zchange > .05)
+                {
                     grav.Z = (float)(grav.Z * 1.25);
+                }
                 if (Zchange > .025)
+                {
                     grav.Z = (float)(grav.Z * 1.125);
-                float postemp = (pos.Z - terrainHeight);
+                }
+                float terraintemp = m_prim.Scene.GetTerrainHeightAtXYZ(pos);
+                float postemp = (pos.Z - terraintemp);
                 if (postemp > 2.5f)
+                {
                     grav.Z = (float)(grav.Z * 1.037125);
-                VDetailLog("{0},MoveLinear,limitMotorUp,grav={1}", Prim.LocalID, grav);
+                }
+                DetailLog("{0},MoveLinear,limitMotorUp,grav={1}", m_prim.LocalID, grav);
+                //End Experimental Values
             }
-
-            // If not changing some axis, reduce out velocity
             if ((m_flags & (VehicleFlag.NO_X)) != 0)
-                m_newVelocity.X = 0;
+            {
+                m_dir.X = 0;
+            }
             if ((m_flags & (VehicleFlag.NO_Y)) != 0)
-                m_newVelocity.Y = 0;
+            {
+                m_dir.Y = 0;
+            }
             if ((m_flags & (VehicleFlag.NO_Z)) != 0)
-                m_newVelocity.Z = 0;
+            {
+                m_dir.Z = 0;
+            }
+
+            m_lastPositionVector = m_prim.Position;
 
             // Apply velocity
-            Prim.ForceVelocity = m_newVelocity;
-            // Prim.AddForce(m_newVelocity * Prim.Linkset.LinksetMass, false);
-            Prim.AddForce(grav * Prim.Linkset.LinksetMass, false);
+            m_prim.Velocity = m_dir;
+            // apply gravity force
+            // Why is this set here? The physics engine already does gravity.
+            // m_prim.AddForce(grav, false);
+            // m_prim.Force = grav;
 
-            VDetailLog("{0},MoveLinear,done,lmDir={1},lmVel={2},newVel={3},grav={4}",
-                    Prim.LocalID, m_linearMotorDirection, m_lastLinearVelocityVector, m_newVelocity, grav);
+            // Apply friction
+            Vector3 decayamount = Vector3.One / (m_linearFrictionTimescale / pTimestep);
+            m_lastLinearVelocityVector -= m_lastLinearVelocityVector * decayamount;
+
+            DetailLog("{0},MoveLinear,done,pos={1},vel={2},force={3},decay={4}", 
+                        m_prim.LocalID, m_lastPositionVector, m_dir, grav, decayamount);
 
         } // end MoveLinear()
 
-        // =======================================================================
-        // Apply the effect of the angular motor.
         private void MoveAngular(float pTimestep)
         {
             // m_angularMotorDirection         // angular velocity requested by LSL motor
@@ -759,223 +859,160 @@ namespace OpenSim.Region.Physics.BulletSPlugin
             // m_angularFrictionTimescale      // body angular velocity  decay rate
             // m_lastAngularVelocity           // what was last applied to body
 
-            if (m_angularMotorDirection.LengthSquared() > 0.0001)
-            {
-                Vector3 origVel = m_angularMotorVelocity;
-                Vector3 origDir = m_angularMotorDirection;
-
-                //       new velocity    +=                      error                       /  (  time to get there   / step interval)
-                //                             requested speed     -    last motor speed
-                m_angularMotorVelocity += (m_angularMotorDirection - m_angularMotorVelocity) /  (m_angularMotorTimescale / pTimestep);
-                // decay requested direction
-                m_angularMotorDirection *= (1.0f - (pTimestep * 1.0f/m_angularMotorDecayTimescale));
+            // Get what the body is doing, this includes 'external' influences
+            Vector3 angularVelocity = m_prim.RotationalVelocity;
 
-                VDetailLog("{0},MoveAngular,angularMotorApply,angTScale={1},timeStep={2},origvel={3},origDir={4},vel={5}",
-                        Prim.LocalID, m_angularMotorTimescale, pTimestep, origVel, origDir, m_angularMotorVelocity);
+            if (m_angularMotorApply > 0)
+            {
+                // Rather than snapping the angular motor velocity from the old value to
+                //    a newly set velocity, this routine steps the value from the previous
+                //    value (m_angularMotorVelocity) to the requested value (m_angularMotorDirection).
+                // There are m_angularMotorApply steps.
+                Vector3 origAngularVelocity = m_angularMotorVelocity;
+                // ramp up to new value
+                //   current velocity  +=                         error                       /    (time to get there / step interval)
+                //                               requested speed            -  last motor speed
+                m_angularMotorVelocity.X += (m_angularMotorDirection.X - m_angularMotorVelocity.X) /  (m_angularMotorTimescale / pTimestep);
+                m_angularMotorVelocity.Y += (m_angularMotorDirection.Y - m_angularMotorVelocity.Y) /  (m_angularMotorTimescale / pTimestep);
+                m_angularMotorVelocity.Z += (m_angularMotorDirection.Z - m_angularMotorVelocity.Z) /  (m_angularMotorTimescale / pTimestep);
+
+                DetailLog("{0},MoveAngular,angularMotorApply,apply={1},origvel={2},dir={3},vel={4}", 
+                        m_prim.LocalID,m_angularMotorApply,origAngularVelocity, m_angularMotorDirection, m_angularMotorVelocity);
+
+                m_angularMotorApply--;        // This is done so that if script request rate is less than phys frame rate the expected
+                                            // velocity may still be acheived.
             }
             else
             {
-                m_angularMotorVelocity = Vector3.Zero;
-            }
-
-            #region Vertical attactor
+                // No motor recently applied, keep the body velocity
+                // and decay the velocity
+                m_angularMotorVelocity -= m_angularMotorVelocity /  (m_angularMotorDecayTimescale / pTimestep);
+            } // end motor section
 
+            // Vertical attractor section
             Vector3 vertattr = Vector3.Zero;
-            Vector3 deflection = Vector3.Zero;
-            Vector3 banking = Vector3.Zero;
-
-            if (m_verticalAttractionTimescale < 300 && m_lastAngularVelocity != Vector3.Zero)
+            if (m_verticalAttractionTimescale < 300)
             {
-                float VAservo = pTimestep * 0.2f / m_verticalAttractionTimescale;
-                if (Prim.Linkset.LinksetIsColliding)
-                    VAservo = pTimestep * 0.05f / (m_verticalAttractionTimescale);
-
-                VAservo *= (m_verticalAttractionEfficiency * m_verticalAttractionEfficiency);
-
-                // Create a vector of the vehicle "up" in world coordinates
-                Vector3 verticalError = Vector3.UnitZ * Prim.ForceOrientation;
-                // verticalError.X and .Y are the World error amounts. They are 0 when there is no
-                //      error (Vehicle Body is 'vertical'), and .Z will be 1. As the body leans to its
-                //      side |.X| will increase to 1 and .Z fall to 0. As body inverts |.X| will fall
-                //      and .Z will go // negative. Similar for tilt and |.Y|. .X and .Y must be
-                //      modulated to prevent a stable inverted body.
-
-                // Error is 0 (no error) to +/- 2 (max error)
-                if (verticalError.Z < 0.0f)
+                float VAservo = 0.2f / (m_verticalAttractionTimescale * pTimestep);
+                // get present body rotation
+                Quaternion rotq = m_prim.Orientation;
+                // make a vector pointing up
+                Vector3 verterr = Vector3.Zero;
+                verterr.Z = 1.0f;
+                // rotate it to Body Angle
+                verterr = verterr * rotq;
+                // verterr.X and .Y are the World error ammounts. They are 0 when there is no error (Vehicle Body is 'vertical'), and .Z will be 1.
+                // As the body leans to its side |.X| will increase to 1 and .Z fall to 0. As body inverts |.X| will fall and .Z will go
+                // negative. Similar for tilt and |.Y|. .X and .Y must be modulated to prevent a stable inverted body.
+                if (verterr.Z < 0.0f)
                 {
-                    verticalError.X = 2.0f - verticalError.X;
-                    verticalError.Y = 2.0f - verticalError.Y;
+                    verterr.X = 2.0f - verterr.X;
+                    verterr.Y = 2.0f - verterr.Y;
                 }
+                // Error is 0 (no error) to +/- 2 (max error)
                 // scale it by VAservo
-                verticalError = verticalError * VAservo;
+                verterr = verterr * VAservo;
 
-                // As the body rotates around the X axis, then verticalError.Y increases; Rotated around Y
-                //     then .X increases, so change  Body angular velocity  X based on Y, and Y based on X.
-                //     Z is not changed.
-                vertattr.X =    verticalError.Y;
-                vertattr.Y =  - verticalError.X;
+                // As the body rotates around the X axis, then verterr.Y increases; Rotated around Y then .X increases, so
+                // Change  Body angular velocity  X based on Y, and Y based on X. Z is not changed.
+                vertattr.X =    verterr.Y;
+                vertattr.Y =  - verterr.X;
                 vertattr.Z = 0f;
 
                 // scaling appears better usingsquare-law
-                Vector3 angularVelocity = Prim.ForceRotationalVelocity;
                 float bounce = 1.0f - (m_verticalAttractionEfficiency * m_verticalAttractionEfficiency);
                 vertattr.X += bounce * angularVelocity.X;
                 vertattr.Y += bounce * angularVelocity.Y;
 
-                VDetailLog("{0},MoveAngular,verticalAttraction,verticalError={1},bounce={2},vertattr={3}",
-                            Prim.LocalID, verticalError, bounce, vertattr);
-
-            }
-            #endregion // Vertical attactor
-
-            #region Deflection
-
-            //Forward is the prefered direction, but if the reference frame has changed, we need to take this into account as well
-            if (m_angularDeflectionEfficiency != 0)
-            {
-                Vector3 preferredAxisOfMotion =
-                    new Vector3((pTimestep * 10 * (m_angularDeflectionEfficiency / m_angularDeflectionTimescale)), 0, 0);
-                preferredAxisOfMotion *= Quaternion.Add(Prim.ForceOrientation, m_referenceFrame);
-
-                deflection = (preferredAxisOfMotion * (m_angularDeflectionEfficiency) / m_angularDeflectionTimescale) * pTimestep;
-
-                VDetailLog("{0},MoveAngular,Deflection,perfAxis={1},deflection={2}", 
-                                        Prim.LocalID, preferredAxisOfMotion, deflection);
-            }
-
-            #endregion
-
-            #region Banking
+                DetailLog("{0},MoveAngular,verticalAttraction,verterr={1},bounce={2},vertattr={3}", 
+                            m_prim.LocalID, verterr, bounce, vertattr);
 
-            if (m_bankingEfficiency != 0)
-            {
-                Vector3 dir = Vector3.One * Prim.ForceOrientation;
-                float mult = (m_bankingMix*m_bankingMix)*-1*(m_bankingMix < 0 ? -1 : 1);
-                    //Changes which way it banks in and out of turns
+            } // else vertical attractor is off
 
-                //Use the square of the efficiency, as it looks much more how SL banking works
-                float effSquared = (m_bankingEfficiency*m_bankingEfficiency);
-                if (m_bankingEfficiency < 0)
-                    effSquared *= -1; //Keep the negative!
+            // m_lastVertAttractor = vertattr;
 
-                float mix = Math.Abs(m_bankingMix);
-                if (m_angularMotorVelocity.X == 0)
-                {
-                    /*if (!parent.Orientation.ApproxEquals(this.m_referenceFrame, 0.25f))
-                    {
-                        Vector3 axisAngle;
-                        float angle;
-                        parent.Orientation.GetAxisAngle(out axisAngle, out angle);
-                        Vector3 rotatedVel = parent.Velocity * parent.Orientation;
-                        if ((rotatedVel.X < 0 && axisAngle.Y > 0) || (rotatedVel.X > 0 && axisAngle.Y < 0))
-                            m_angularMotorVelocity.X += (effSquared * (mult * mix)) * (1f) * 10;
-                        else
-                            m_angularMotorVelocity.X += (effSquared * (mult * mix)) * (-1f) * 10;
-                    }*/
-                }
-                else
-                    banking.Z += (effSquared*(mult*mix))*(m_angularMotorVelocity.X) * 4;
-                if (!Prim.Linkset.LinksetIsColliding && Math.Abs(m_angularMotorVelocity.X) > mix)
-                    //If they are colliding, we probably shouldn't shove the prim around... probably
-                {
-                    float angVelZ = m_angularMotorVelocity.X*-1;
-                    /*if(angVelZ > mix)
-                        angVelZ = mix;
-                    else if(angVelZ < -mix)
-                        angVelZ = -mix;*/
-                    //This controls how fast and how far the banking occurs
-                    Vector3 bankingRot = new Vector3(angVelZ*(effSquared*mult), 0, 0);
-                    if (bankingRot.X > 3)
-                        bankingRot.X = 3;
-                    else if (bankingRot.X < -3)
-                        bankingRot.X = -3;
-                    bankingRot *= Prim.ForceOrientation;
-                    banking += bankingRot;
-                }
-                m_angularMotorVelocity.X *= m_bankingEfficiency == 1 ? 0.0f : 1 - m_bankingEfficiency;
-                VDetailLog("{0},MoveAngular,Banking,bEff={1},angMotVel={2},banking={3}", 
-                                Prim.LocalID, m_bankingEfficiency, m_angularMotorVelocity, banking);
-            }
-
-            #endregion
+            // Bank section tba
 
-            m_lastVertAttractor = vertattr;
+            // Deflection section tba
 
             // Sum velocities
-            m_lastAngularVelocity = m_angularMotorVelocity + vertattr + banking + deflection;
-
+            m_lastAngularVelocity = m_angularMotorVelocity + vertattr; // + bank + deflection
+            
             if ((m_flags & (VehicleFlag.NO_DEFLECTION_UP)) != 0)
             {
                 m_lastAngularVelocity.X = 0;
                 m_lastAngularVelocity.Y = 0;
-                VDetailLog("{0},MoveAngular,noDeflectionUp,lastAngular={1}", Prim.LocalID, m_lastAngularVelocity);
+                DetailLog("{0},MoveAngular,noDeflectionUp,lastAngular={1}", m_prim.LocalID, m_lastAngularVelocity);
             }
 
             if (m_lastAngularVelocity.ApproxEquals(Vector3.Zero, 0.01f))
             {
                 m_lastAngularVelocity = Vector3.Zero; // Reduce small value to zero.
-                VDetailLog("{0},MoveAngular,zeroSmallValues,lastAngular={1}", Prim.LocalID, m_lastAngularVelocity);
+                DetailLog("{0},MoveAngular,zeroSmallValues,lastAngular={1}", m_prim.LocalID, m_lastAngularVelocity);
             }
 
-            // Apply to the body
-            // The above calculates the absolute angular velocity needed
-            // Prim.ForceRotationalVelocity = m_lastAngularVelocity;
-
-            // Apply a force to overcome current angular velocity
-            Vector3 applyAngularForce = (m_lastAngularVelocity - Prim.ForceRotationalVelocity) * Prim.Linkset.LinksetMass;
-            // Vector3 applyAngularForce = (m_lastAngularVelocity - Prim.ForceRotationalVelocity);
-            // Prim.AddAngularForce(applyAngularForce, false);
-            Prim.ApplyTorqueImpulse(applyAngularForce, false);
+             // apply friction
+            Vector3 decayamount = Vector3.One / (m_angularFrictionTimescale / pTimestep);
+            m_lastAngularVelocity -= m_lastAngularVelocity * decayamount;
 
-             // Apply friction for next time
-            Vector3 decayamount = (Vector3.One / m_angularFrictionTimescale) * pTimestep;
-            m_lastAngularVelocity *= Vector3.One - decayamount;
+            // Apply to the body
+            m_prim.RotationalVelocity = m_lastAngularVelocity;
 
-            VDetailLog("{0},MoveAngular,done,applyAForce={1},decay={2},lastAngular={3}", 
-                                Prim.LocalID, applyAngularForce, decayamount, m_lastAngularVelocity);
+            DetailLog("{0},MoveAngular,done,decay={1},lastAngular={2}", m_prim.LocalID, decayamount, m_lastAngularVelocity);
         } //end MoveAngular
 
         internal void LimitRotation(float timestep)
         {
-            Quaternion rotq = Prim.ForceOrientation;
+            Quaternion rotq = m_prim.Orientation;
             Quaternion m_rot = rotq;
+            bool changed = false;
             if (m_RollreferenceFrame != Quaternion.Identity)
             {
                 if (rotq.X >= m_RollreferenceFrame.X)
                 {
                     m_rot.X = rotq.X - (m_RollreferenceFrame.X / 2);
+                    changed = true;
                 }
                 if (rotq.Y >= m_RollreferenceFrame.Y)
                 {
                     m_rot.Y = rotq.Y - (m_RollreferenceFrame.Y / 2);
+                    changed = true;
                 }
                 if (rotq.X <= -m_RollreferenceFrame.X)
                 {
                     m_rot.X = rotq.X + (m_RollreferenceFrame.X / 2);
+                    changed = true;
                 }
                 if (rotq.Y <= -m_RollreferenceFrame.Y)
                 {
                     m_rot.Y = rotq.Y + (m_RollreferenceFrame.Y / 2);
+                    changed = true;
                 }
+                changed = true;
             }
             if ((m_flags & VehicleFlag.LOCK_ROTATION) != 0)
             {
                 m_rot.X = 0;
                 m_rot.Y = 0;
+                changed = true;
             }
-            if (rotq != m_rot)
+            if ((m_flags & VehicleFlag.LOCK_ROTATION) != 0)
             {
-                Prim.ForceOrientation = m_rot;
-                VDetailLog("{0},LimitRotation,done,orig={1},new={2}", Prim.LocalID, rotq, m_rot);
+                m_rot.X = 0;
+                m_rot.Y = 0;
+                changed = true;
             }
+            if (changed)
+                m_prim.Orientation = m_rot;
 
+            DetailLog("{0},LimitRotation,done,changed={1},orig={2},new={3}", m_prim.LocalID, changed, rotq, m_rot);
         }
 
         // Invoke the detailed logger and output something if it's enabled.
-        private void VDetailLog(string msg, params Object[] args)
+        private void DetailLog(string msg, params Object[] args)
         {
-            if (Prim.PhysicsScene.VehicleLoggingEnabled)
-                Prim.PhysicsScene.DetailLog(msg, args);
+            if (m_prim.Scene.VehicleLoggingEnabled)
+                m_prim.Scene.PhysicsLogging.Write(msg, args);
         }
     }
 }
diff --git a/OpenSim/Region/Physics/BulletSPlugin/BSConstraintHinge.cs b/OpenSim/Region/Physics/BulletSPlugin/BSHingeConstraint.cs
index ed3ffa7..d68048b 100755
--- a/OpenSim/Region/Physics/BulletSPlugin/BSConstraintHinge.cs
+++ b/OpenSim/Region/Physics/BulletSPlugin/BSHingeConstraint.cs
@@ -1,57 +1,55 @@
-/*
- * Copyright (c) Contributors, http://opensimulator.org/
- * See CONTRIBUTORS.TXT for a full list of copyright holders.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *     * Redistributions of source code must retain the above copyright
- *       notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyrightD
- *       notice, this list of conditions and the following disclaimer in the
- *       documentation and/or other materials provided with the distribution.
- *     * Neither the name of the OpenSimulator Project nor the
- *       names of its contributors may be used to endorse or promote products
- *       derived from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
- * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
- * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-using System;
-using System.Collections.Generic;
-using System.Text;
-using OpenMetaverse;
-
-namespace OpenSim.Region.Physics.BulletSPlugin
-{
-
-public sealed class BSConstraintHinge : BSConstraint
-{
-    public override ConstraintType Type { get { return ConstraintType.HINGE_CONSTRAINT_TYPE; } }
-
-    public BSConstraintHinge(BulletSim world, BulletBody obj1, BulletBody obj2,
-                    Vector3 pivotInA, Vector3 pivotInB,
-                    Vector3 axisInA, Vector3 axisInB,
-                    bool useLinearReferenceFrameA, bool disableCollisionsBetweenLinkedBodies)
-    {
-        m_world = world;
-        m_body1 = obj1;
-        m_body2 = obj2;
-        m_constraint = new BulletConstraint(
-                            BulletSimAPI.CreateHingeConstraint2(m_world.ptr, m_body1.ptr, m_body2.ptr,
-                                pivotInA, pivotInB,
-                                axisInA, axisInB,
-                                useLinearReferenceFrameA, disableCollisionsBetweenLinkedBodies));
-        m_enabled = true;
-    }
-
-}
-
-}
+/*

+ * Copyright (c) Contributors, http://opensimulator.org/

+ * See CONTRIBUTORS.TXT for a full list of copyright holders.

+ *

+ * Redistribution and use in source and binary forms, with or without

+ * modification, are permitted provided that the following conditions are met:

+ *     * Redistributions of source code must retain the above copyright

+ *       notice, this list of conditions and the following disclaimer.

+ *     * Redistributions in binary form must reproduce the above copyrightD

+ *       notice, this list of conditions and the following disclaimer in the

+ *       documentation and/or other materials provided with the distribution.

+ *     * Neither the name of the OpenSimulator Project nor the

+ *       names of its contributors may be used to endorse or promote products

+ *       derived from this software without specific prior written permission.

+ *

+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY

+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED

+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE

+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY

+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES

+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;

+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND

+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS

+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

+ */

+using System;

+using System.Collections.Generic;

+using System.Text;

+using OpenMetaverse;

+

+namespace OpenSim.Region.Physics.BulletSPlugin

+{

+

+class BSHingeConstraint : BSConstraint

+{

+    public BSHingeConstraint(BulletSim world, BulletBody obj1, BulletBody obj2,

+                    Vector3 pivotInA, Vector3 pivotInB,

+                    Vector3 axisInA, Vector3 axisInB,

+                    bool useLinearReferenceFrameA, bool disableCollisionsBetweenLinkedBodies)

+    {

+        m_world = world;

+        m_body1 = obj1;

+        m_body2 = obj2;

+        m_constraint = new BulletConstraint(

+                            BulletSimAPI.CreateHingeConstraint2(m_world.Ptr, m_body1.Ptr, m_body2.Ptr,

+                                pivotInA, pivotInB,

+                                axisInA, axisInB,

+                                useLinearReferenceFrameA, disableCollisionsBetweenLinkedBodies));

+        m_enabled = true;

+    }

+

+}

+

+}

diff --git a/OpenSim/Region/Physics/BulletSPlugin/BSLinkset.cs b/OpenSim/Region/Physics/BulletSPlugin/BSLinkset.cs
index 3a92f93..087b9bb 100755
--- a/OpenSim/Region/Physics/BulletSPlugin/BSLinkset.cs
+++ b/OpenSim/Region/Physics/BulletSPlugin/BSLinkset.cs
@@ -32,78 +32,35 @@ using OMV = OpenMetaverse;
 
 namespace OpenSim.Region.Physics.BulletSPlugin
 {
-public abstract class BSLinkset
+public class BSLinkset
 {
-    // private static string LogHeader = "[BULLETSIM LINKSET]";
+    private static string LogHeader = "[BULLETSIM LINKSET]";
 
-    public enum LinksetImplementation
-    {
-        Constraint   = 0,   // linkset tied together with constraints
-        Compound     = 1,   // linkset tied together as a compound object
-        Manual       = 2    // linkset tied together manually (code moves all the pieces)
-    }
-    // Create the correct type of linkset for this child
-    public static BSLinkset Factory(BSScene physScene, BSPhysObject parent)
-    {
-        BSLinkset ret = null;
-
-        switch ((int)physScene.Params.linksetImplementation)
-        {
-            case (int)LinksetImplementation.Compound:
-                ret = new BSLinksetCompound(physScene, parent);
-                break;
-            case (int)LinksetImplementation.Manual:
-                // ret = new BSLinksetManual(physScene, parent);
-                break;
-            default:
-                ret = new BSLinksetConstraints(physScene, parent);
-                break;
-        }
-        return ret;
-    }
-
-    public BSPhysObject LinksetRoot { get; protected set; }
+    private BSPrim m_linksetRoot;
+    public BSPrim LinksetRoot { get { return m_linksetRoot; } }
 
-    public BSScene PhysicsScene { get; private set; }
+    private BSScene m_physicsScene;
+    public BSScene PhysicsScene { get { return m_physicsScene; } }
 
-    static int m_nextLinksetID = 1;
-    public int LinksetID { get; private set; }
-
-    // The children under the root in this linkset.
-    protected HashSet<BSPhysObject> m_children;
+    // The children under the root in this linkset
+    private List<BSPrim> m_children;
 
     // We lock the diddling of linkset classes to prevent any badness.
     // This locks the modification of the instances of this class. Changes
     //    to the physical representation is done via the tainting mechenism.
-    protected object m_linksetActivityLock = new Object();
-
-    // Some linksets have a preferred physical shape.
-    // Returns SHAPE_UNKNOWN if there is no preference. Causes the correct shape to be selected.
-    public virtual ShapeData.PhysicsShapeType PreferredPhysicalShape(BSPhysObject requestor)
-    {
-        return ShapeData.PhysicsShapeType.SHAPE_UNKNOWN;
-    }
+    private object m_linksetActivityLock = new Object();
 
-    // Linksets move around the children so the linkset might need to compute the child position
-    public virtual OMV.Vector3 Position(BSPhysObject member)
-        { return member.RawPosition; }
-    public virtual OMV.Quaternion Orientation(BSPhysObject member)
-        { return member.RawOrientation; }
-    // TODO: does this need to be done for Velocity and RotationalVelocityy?
-    
     // We keep the prim's mass in the linkset structure since it could be dependent on other prims
-    protected float m_mass;
-    public float LinksetMass
-    {
-        get
+    private float m_mass;
+    public float LinksetMass 
+    { 
+        get 
         {
             m_mass = ComputeLinksetMass();
             return m_mass;
         }
     }
 
-    public virtual bool LinksetIsColliding { get { return false; } }
-
     public OMV.Vector3 CenterOfMass
     {
         get { return ComputeLinksetCenterOfMass(); }
@@ -114,30 +71,23 @@ public abstract class BSLinkset
         get { return ComputeLinksetGeometricCenter(); }
     }
 
-    protected void Initialize(BSScene scene, BSPhysObject parent)
+    public BSLinkset(BSScene scene, BSPrim parent)
     {
         // A simple linkset of one (no children)
-        LinksetID = m_nextLinksetID++;
-        // We create LOTS of linksets.
-        if (m_nextLinksetID <= 0)
-            m_nextLinksetID = 1;
-        PhysicsScene = scene;
-        LinksetRoot = parent;
-        m_children = new HashSet<BSPhysObject>();
-        m_mass = parent.RawMass;
+        m_physicsScene = scene;
+        m_linksetRoot = parent;
+        m_children = new List<BSPrim>();
+        m_mass = parent.MassRaw;
     }
 
     // Link to a linkset where the child knows the parent.
     // Parent changing should not happen so do some sanity checking.
     // We return the parent's linkset so the child can track its membership.
-    // Called at runtime.
-    public BSLinkset AddMeToLinkset(BSPhysObject child)
+    public BSLinkset AddMeToLinkset(BSPrim child)
     {
         lock (m_linksetActivityLock)
         {
-            // Don't add the root to its own linkset
-            if (!IsRoot(child))
-                AddChildToLinkset(child);
+            AddChildToLinkset(child);
         }
         return this;
     }
@@ -145,27 +95,36 @@ public abstract class BSLinkset
     // Remove a child from a linkset.
     // Returns a new linkset for the child which is a linkset of one (just the
     //    orphened child).
-    // Called at runtime.
-    public BSLinkset RemoveMeFromLinkset(BSPhysObject child)
+    public BSLinkset RemoveMeFromLinkset(BSPrim child)
     {
         lock (m_linksetActivityLock)
         {
             if (IsRoot(child))
             {
-                // Cannot remove the root from a linkset.
-                return this;
+                // if root of linkset, take the linkset apart
+                while (m_children.Count > 0)
+                {
+                    // Note that we don't do a foreach because the remove routine
+                    //    takes it out of the list.
+                    RemoveChildFromOtherLinkset(m_children[0]);
+                }
+                m_children.Clear(); // just to make sure
+            }
+            else
+            {
+                // Just removing a child from an existing linkset
+                RemoveChildFromLinkset(child);
             }
-            RemoveChildFromLinkset(child);
         }
 
         // The child is down to a linkset of just itself
-        return BSLinkset.Factory(PhysicsScene, child);
+        return new BSLinkset(PhysicsScene, child);
     }
 
     // Return 'true' if the passed object is the root object of this linkset
-    public bool IsRoot(BSPhysObject requestor)
+    public bool IsRoot(BSPrim requestor)
     {
-        return (requestor.LocalID == LinksetRoot.LocalID);
+        return (requestor.LocalID == m_linksetRoot.LocalID);
     }
 
     public int NumberOfChildren { get { return m_children.Count; } }
@@ -174,14 +133,12 @@ public abstract class BSLinkset
     public bool HasAnyChildren { get { return (m_children.Count > 0); } }
 
     // Return 'true' if this child is in this linkset
-    public bool HasChild(BSPhysObject child)
+    public bool HasChild(BSPrim child)
     {
         bool ret = false;
         lock (m_linksetActivityLock)
         {
-            ret = m_children.Contains(child);
-            /* Safer version but the above should work
-            foreach (BSPhysObject bp in m_children)
+            foreach (BSPrim bp in m_children)
             {
                 if (child.LocalID == bp.LocalID)
                 {
@@ -189,132 +146,274 @@ public abstract class BSLinkset
                     break;
                 }
             }
-             */
         }
         return ret;
     }
 
-    // Perform an action on each member of the linkset including root prim.
-    // Depends on the action on whether this should be done at taint time.
-    public delegate bool ForEachMemberAction(BSPhysObject obj);
-    public virtual bool ForEachMember(ForEachMemberAction action)
+    private float ComputeLinksetMass()
     {
-        bool ret = false;
+        float mass = m_linksetRoot.MassRaw;
+        foreach (BSPrim bp in m_children)
+        {
+            mass += bp.MassRaw;
+        }
+        return mass;
+    }
+
+    private OMV.Vector3 ComputeLinksetCenterOfMass()
+    {
+        OMV.Vector3 com = m_linksetRoot.Position * m_linksetRoot.MassRaw;
+        float totalMass = m_linksetRoot.MassRaw;
+
         lock (m_linksetActivityLock)
         {
-            action(LinksetRoot);
-            foreach (BSPhysObject po in m_children)
+            foreach (BSPrim bp in m_children)
             {
-                if (action(po))
-                    break;
+                com += bp.Position * bp.MassRaw;
+                totalMass += bp.MassRaw;
             }
+            if (totalMass != 0f)
+                com /= totalMass;
         }
-        return ret;
+
+        return com;
     }
 
-    // I am the root of a linkset and a new child is being added
-    // Called while LinkActivity is locked.
-    protected abstract void AddChildToLinkset(BSPhysObject child);
+    private OMV.Vector3 ComputeLinksetGeometricCenter()
+    {
+        OMV.Vector3 com = m_linksetRoot.Position;
 
-    // I am the root of a linkset and one of my children is being removed.
-    // Safe to call even if the child is not really in my linkset.
-    protected abstract void RemoveChildFromLinkset(BSPhysObject child);
+        lock (m_linksetActivityLock)
+        {
+            foreach (BSPrim bp in m_children)
+            {
+                com += bp.Position * bp.MassRaw;
+            }
+            com /= (m_children.Count + 1);
+        }
+
+        return com;
+    }
 
     // When physical properties are changed the linkset needs to recalculate
     //   its internal properties.
-    // May be called at runtime or taint-time.
-    public abstract void Refresh(BSPhysObject requestor);
-
-    // 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.
-    // Return 'true' if any properties updated on the passed object.
-    // Called at taint-time!
-    public abstract bool MakeDynamic(BSPhysObject child);
-
-    // 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.
-    // Called at taint-time!
-    public abstract bool MakeStatic(BSPhysObject child);
-
-    // Called when a parameter update comes from the physics engine for any object
-    //      of the linkset is received.
-    // Called at taint-time!!
-    public abstract void UpdateProperties(BSPhysObject physObject);
-
-    // Routine used when rebuilding the body of the root of the linkset
-    // Destroy all the constraints have have been made to root.
-    // This is called when the root body is changing.
-    // Returns 'true' of something was actually removed and would need restoring
-    // Called at taint-time!!
-    public abstract bool RemoveBodyDependencies(BSPrim child);
-
-    // Companion to RemoveBodyDependencies(). If RemoveBodyDependencies() returns 'true',
-    //     this routine will restore the removed constraints.
-    // Called at taint-time!!
-    public abstract void RestoreBodyDependencies(BSPrim child);
-
-    // ================================================================
-    protected virtual float ComputeLinksetMass()
+    public void Refresh(BSPrim requestor)
     {
-        float mass = LinksetRoot.RawMass;
-        if (HasAnyChildren)
+        // If there are no children, there aren't any constraints to recompute
+        if (!HasAnyChildren)
+            return;
+
+        // Only the root does the recomputation
+        if (IsRoot(requestor))
+        {
+            PhysicsScene.TaintedObject("BSLinkSet.Refresh", delegate()
+            {
+                RecomputeLinksetConstraintVariables();
+            });
+        }
+    }
+
+    // Call each of the constraints that make up this linkset and recompute the
+    //    various transforms and variables. Used when objects are added or removed
+    //    from a linkset to make sure the constraints know about the new mass and
+    //    geometry.
+    // Must only be called at taint time!!
+    private bool RecomputeLinksetConstraintVariables()
+    {
+        float linksetMass = LinksetMass;
+        lock (m_linksetActivityLock)
         {
-            lock (m_linksetActivityLock)
+            foreach (BSPrim child in m_children)
             {
-                foreach (BSPhysObject bp in m_children)
+                BSConstraint constrain;
+                if (m_physicsScene.Constraints.TryGetConstraint(LinksetRoot.Body, child.Body, out constrain))
+                {
+                    // DetailLog("{0},BSLinkset.RecomputeLinksetConstraintVariables,taint,child={1},mass={2},A={3},B={4}", 
+                    //         LinksetRoot.LocalID, child.LocalID, linksetMass, constrain.Body1.ID, constrain.Body2.ID);
+                    constrain.RecomputeConstraintVariables(linksetMass);
+                }
+                else
                 {
-                    mass += bp.RawMass;
+                    // Non-fatal error that can happen when children are being added to the linkset but
+                    //    their constraints have not been created yet.
+                    // Caused by the fact that m_children is built at run time but building constraints
+                    //    happens at taint time.
+                    // m_physicsScene.Logger.ErrorFormat("[BULLETSIM LINKSET] RecomputeLinksetConstraintVariables: constraint not found for root={0}, child={1}",
+                    //                                 m_linksetRoot.Body.ID, child.Body.ID);
                 }
             }
         }
-        return mass;
+        return false;
     }
 
-    protected virtual OMV.Vector3 ComputeLinksetCenterOfMass()
+    // I am the root of a linkset and a new child is being added
+    // Called while LinkActivity is locked.
+    private void AddChildToLinkset(BSPrim child)
     {
-        OMV.Vector3 com;
-        lock (m_linksetActivityLock)
+        if (!HasChild(child))
         {
-            com = LinksetRoot.Position * LinksetRoot.RawMass;
-            float totalMass = LinksetRoot.RawMass;
+            m_children.Add(child);
 
-            foreach (BSPhysObject bp in m_children)
+            BSPrim rootx = LinksetRoot; // capture the root as of now
+            BSPrim childx = child;
+            m_physicsScene.TaintedObject("AddChildToLinkset", delegate()
             {
-                com += bp.Position * bp.RawMass;
-                totalMass += bp.RawMass;
-            }
-            if (totalMass != 0f)
-                com /= totalMass;
+                // DebugLog("{0}: AddChildToLinkset: adding child {1} to {2}", LogHeader, child.LocalID, m_linksetRoot.LocalID);
+                // DetailLog("{0},AddChildToLinkset,taint,child={1}", m_linksetRoot.LocalID, child.LocalID);
+                PhysicallyLinkAChildToRoot(rootx, childx);     // build the physical binding between me and the child
+            });
         }
+        return;
+    }
 
-        return com;
+    // Forcefully removing a child from a linkset.
+    // This is not being called by the child so we have to make sure the child doesn't think
+    //    it's still connected to the linkset.
+    // Normal OpenSimulator operation will never do this because other SceneObjectPart information
+    //    has to be updated also (like pointer to prim's parent).
+    private void RemoveChildFromOtherLinkset(BSPrim pchild)
+    {
+        pchild.Linkset = new BSLinkset(m_physicsScene, pchild);
+        RemoveChildFromLinkset(pchild);
     }
 
-    protected virtual OMV.Vector3 ComputeLinksetGeometricCenter()
+    // I am the root of a linkset and one of my children is being removed.
+    // Safe to call even if the child is not really in my linkset.
+    private void RemoveChildFromLinkset(BSPrim child)
     {
-        OMV.Vector3 com;
-        lock (m_linksetActivityLock)
+        if (m_children.Remove(child))
         {
-            com = LinksetRoot.Position;
-
-            foreach (BSPhysObject bp in m_children)
+            BSPrim rootx = LinksetRoot; // capture the root as of now
+            BSPrim childx = child;
+            m_physicsScene.TaintedObject("RemoveChildFromLinkset", delegate()
             {
-                com += bp.Position * bp.RawMass;
-            }
-            com /= (m_children.Count + 1);
+                // DebugLog("{0}: RemoveChildFromLinkset: Removing constraint to {1}", LogHeader, child.LocalID);
+                // DetailLog("{0},RemoveChildFromLinkset,taint,child={1}", m_linksetRoot.LocalID, child.LocalID);
+
+                PhysicallyUnlinkAChildFromRoot(rootx, childx);
+            });
+
+            RecomputeLinksetConstraintVariables();
+        }
+        else
+        {
+            // This will happen if we remove the root of the linkset first. Non-fatal occurance.
+            // PhysicsScene.Logger.ErrorFormat("{0}: Asked to remove child from linkset that was not in linkset", LogHeader);
         }
+        return;
+    }
 
-        return com;
+    // Create a constraint between me (root of linkset) and the passed prim (the child).
+    // Called at taint time!
+    private void PhysicallyLinkAChildToRoot(BSPrim rootPrim, BSPrim childPrim)
+    {
+        // Zero motion for children so they don't interpolate
+        childPrim.ZeroMotion();
+
+        // Relative position normalized to the root prim
+        // Essentually a vector pointing from center of rootPrim to center of childPrim
+        OMV.Vector3 childRelativePosition = childPrim.Position - rootPrim.Position;
+
+        // real world coordinate of midpoint between the two objects
+        OMV.Vector3 midPoint = rootPrim.Position + (childRelativePosition / 2);
+
+        // create a constraint that allows no freedom of movement between the two objects
+        // http://bulletphysics.org/Bullet/phpBB3/viewtopic.php?t=4818
+        // DebugLog("{0}: CreateLinkset: Adding a constraint between root prim {1} and child prim {2}", LogHeader, LocalID, childPrim.LocalID);
+        DetailLog("{0},PhysicallyLinkAChildToRoot,taint,root={1},child={2},rLoc={3},cLoc={4},midLoc={5}", 
+            rootPrim.LocalID, rootPrim.LocalID, childPrim.LocalID, rootPrim.Position, childPrim.Position, midPoint);
+        BS6DofConstraint constrain = new BS6DofConstraint(
+                        m_physicsScene.World, rootPrim.Body, childPrim.Body,
+                        midPoint,
+                        true,
+                        true
+                        );
+        /* NOTE: attempt to build constraint with full frame computation, etc.
+         *     Using the midpoint is easier since it lets the Bullet code use the transforms
+         *     of the objects.
+         * Code left here as an example.
+        // ==================================================================================
+        // relative position normalized to the root prim
+        OMV.Quaternion invThisOrientation = OMV.Quaternion.Inverse(rootPrim.Orientation);
+        OMV.Vector3 childRelativePosition = (childPrim.Position - rootPrim.Position) * invThisOrientation;
+
+        // relative rotation of the child to the parent
+        OMV.Quaternion childRelativeRotation = invThisOrientation * childPrim.Orientation;
+        OMV.Quaternion inverseChildRelativeRotation = OMV.Quaternion.Inverse(childRelativeRotation);
+
+        // create a constraint that allows no freedom of movement between the two objects
+        // http://bulletphysics.org/Bullet/phpBB3/viewtopic.php?t=4818
+        // DebugLog("{0}: CreateLinkset: Adding a constraint between root prim {1} and child prim {2}", LogHeader, LocalID, childPrim.LocalID);
+        DetailLog("{0},PhysicallyLinkAChildToRoot,taint,root={1},child={2}", rootPrim.LocalID, rootPrim.LocalID, childPrim.LocalID);
+        BS6DofConstraint constrain = new BS6DofConstraint(
+                        PhysicsScene.World, rootPrim.Body, childPrim.Body,
+                        OMV.Vector3.Zero,
+                        OMV.Quaternion.Inverse(rootPrim.Orientation),
+                        OMV.Vector3.Zero,
+                        OMV.Quaternion.Inverse(childPrim.Orientation),
+                        // A point half way between the parent and child
+                        // childRelativePosition/2,
+                        // childRelativeRotation,
+                        // childRelativePosition/2,
+                        // inverseChildRelativeRotation,
+                        true,
+                        true
+                        );
+        // ==================================================================================
+        */
+
+        m_physicsScene.Constraints.AddConstraint(constrain);
+
+        // zero linear and angular limits makes the objects unable to move in relation to each other
+        constrain.SetLinearLimits(OMV.Vector3.Zero, OMV.Vector3.Zero);
+        constrain.SetAngularLimits(OMV.Vector3.Zero, OMV.Vector3.Zero);
+
+        // tweek the constraint to increase stability
+        constrain.UseFrameOffset(PhysicsScene.BoolNumeric(PhysicsScene.Params.linkConstraintUseFrameOffset));
+        constrain.TranslationalLimitMotor(PhysicsScene.BoolNumeric(PhysicsScene.Params.linkConstraintEnableTransMotor),
+                        PhysicsScene.Params.linkConstraintTransMotorMaxVel,
+                        PhysicsScene.Params.linkConstraintTransMotorMaxForce);
+        constrain.SetCFMAndERP(PhysicsScene.Params.linkConstraintCFM, PhysicsScene.Params.linkConstraintERP);
+
+        RecomputeLinksetConstraintVariables();
+    }
+
+    // Remove linkage between myself and a particular child
+    // Called at taint time!
+    private void PhysicallyUnlinkAChildFromRoot(BSPrim rootPrim, BSPrim childPrim)
+    {
+        // DebugLog("{0}: PhysicallyUnlinkAChildFromRoot: RemoveConstraint between root prim {1} and child prim {2}", 
+        //             LogHeader, rootPrim.LocalID, childPrim.LocalID);
+        DetailLog("{0},PhysicallyUnlinkAChildFromRoot,taint,root={1},child={2}", rootPrim.LocalID, rootPrim.LocalID, childPrim.LocalID);
+
+        // Find the constraint for this link and get rid of it from the overall collection and from my list
+        m_physicsScene.Constraints.RemoveAndDestroyConstraint(rootPrim.Body, childPrim.Body);
+
+        // Make the child refresh its location
+        BulletSimAPI.PushUpdate2(childPrim.Body.Ptr);
+    }
+
+    // Remove linkage between myself and any possible children I might have
+    // Called at taint time!
+    private void PhysicallyUnlinkAllChildrenFromRoot(BSPrim rootPrim)
+    {
+        // DebugLog("{0}: PhysicallyUnlinkAllChildren:", LogHeader);
+        DetailLog("{0},PhysicallyUnlinkAllChildren,taint", rootPrim.LocalID);
+
+        m_physicsScene.Constraints.RemoveAndDestroyConstraint(rootPrim.Body);
+    }
+
+    // Invoke the detailed logger and output something if it's enabled.
+    private void DebugLog(string msg, params Object[] args)
+    {
+        if (m_physicsScene.ShouldDebugLog)
+            m_physicsScene.Logger.DebugFormat(msg, args);
     }
 
     // Invoke the detailed logger and output something if it's enabled.
-    protected void DetailLog(string msg, params Object[] args)
+    private void DetailLog(string msg, params Object[] args)
     {
-        if (PhysicsScene.PhysicsLogging.Enabled)
-            PhysicsScene.DetailLog(msg, args);
+        m_physicsScene.PhysicsLogging.Write(msg, args);
     }
 
 }
diff --git a/OpenSim/Region/Physics/BulletSPlugin/BSLinksetCompound.cs b/OpenSim/Region/Physics/BulletSPlugin/BSLinksetCompound.cs
deleted file mode 100755
index 12c6d7a..0000000
--- a/OpenSim/Region/Physics/BulletSPlugin/BSLinksetCompound.cs
+++ /dev/null
@@ -1,273 +0,0 @@
-/*
- * Copyright (c) Contributors, http://opensimulator.org/
- * See CONTRIBUTORS.TXT for a full list of copyright holders.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *     * Redistributions of source code must retain the above copyright
- *       notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyrightD
- *       notice, this list of conditions and the following disclaimer in the
- *       documentation and/or other materials provided with the distribution.
- *     * Neither the name of the OpenSimulator Project nor the
- *       names of its contributors may be used to endorse or promote products
- *       derived from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
- * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
- * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-using System;
-using System.Collections.Generic;
-using System.Text;
-
-using OMV = OpenMetaverse;
-
-namespace OpenSim.Region.Physics.BulletSPlugin
-{
-public sealed class BSLinksetCompound : BSLinkset
-{
-    private static string LogHeader = "[BULLETSIM LINKSET COMPOUND]";
-
-    public BSLinksetCompound(BSScene scene, BSPhysObject parent)
-    {
-        base.Initialize(scene, parent);
-    }
-
-    // For compound implimented linksets, if there are children, use compound shape for the root.
-    public override ShapeData.PhysicsShapeType PreferredPhysicalShape(BSPhysObject requestor)
-    { 
-        ShapeData.PhysicsShapeType ret = ShapeData.PhysicsShapeType.SHAPE_UNKNOWN;
-        if (IsRoot(requestor) && HasAnyChildren)
-        {
-            ret = ShapeData.PhysicsShapeType.SHAPE_COMPOUND;
-        }
-        // DetailLog("{0},BSLinksetCompound.PreferredPhysicalShape,call,shape={1}", LinksetRoot.LocalID, ret);
-        return ret;
-    }
-
-    // When physical properties are changed the linkset needs to recalculate
-    //   its internal properties.
-    // This is queued in the 'post taint' queue so the
-    //   refresh will happen once after all the other taints are applied.
-    public override void Refresh(BSPhysObject requestor)
-    {
-        // External request for Refresh (from BSPrim) is not necessary
-        // InternalRefresh(requestor);
-    }
-
-    private void InternalRefresh(BSPhysObject requestor)
-    {
-        DetailLog("{0},BSLinksetCompound.Refresh,schedulingRefresh,requestor={1}", LinksetRoot.LocalID, requestor.LocalID);
-        // Queue to happen after all the other taint processing
-        PhysicsScene.PostTaintObject("BSLinksetCompound.Refresh", requestor.LocalID, delegate()
-        {
-            if (IsRoot(requestor) && HasAnyChildren)
-                RecomputeLinksetCompound();
-        });
-    }
-
-    // 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.
-    // Return 'true' if any properties updated on the passed object.
-    // Called at taint-time!
-    public override bool MakeDynamic(BSPhysObject child)
-    {
-        bool ret = false;
-        DetailLog("{0},BSLinksetCompound.MakeDynamic,call,IsRoot={1}", child.LocalID, IsRoot(child));
-        if (!IsRoot(child))
-        {
-            // Physical children are removed from the world as the shape ofthe root compound
-            //     shape takes over.
-            BulletSimAPI.AddToCollisionFlags2(child.PhysBody.ptr, CollisionFlags.CF_NO_CONTACT_RESPONSE);
-            BulletSimAPI.ForceActivationState2(child.PhysBody.ptr, ActivationState.DISABLE_SIMULATION);
-            ret = true;
-        }
-        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.
-    // This doesn't normally happen -- OpenSim removes the objects from the physical
-    //     world if it is a static linkset.
-    // Called at taint-time!
-    public override bool MakeStatic(BSPhysObject child)
-    {
-        bool ret = false;
-        DetailLog("{0},BSLinksetCompound.MakeStatic,call,IsRoot={1}", child.LocalID, IsRoot(child));
-        if (!IsRoot(child))
-        {
-            // The non-physical children can come back to life.
-            BulletSimAPI.RemoveFromCollisionFlags2(child.PhysBody.ptr, CollisionFlags.CF_NO_CONTACT_RESPONSE);
-            // Don't force activation so setting of DISABLE_SIMULATION can stay.
-            BulletSimAPI.Activate2(child.PhysBody.ptr, false);
-            ret = true;
-        }
-        return ret;
-    }
-
-    // Called at taint-time!!
-    public override void UpdateProperties(BSPhysObject updated)
-    {
-        // Nothing to do for constraints on property updates
-    }
-
-    // The children move around in relationship to the root.
-    // Just grab the current values of wherever it is right now.
-    public override OMV.Vector3 Position(BSPhysObject member)
-    {
-        return BulletSimAPI.GetPosition2(member.PhysBody.ptr);
-    }
-
-    public override OMV.Quaternion Orientation(BSPhysObject member)
-    {
-        return BulletSimAPI.GetOrientation2(member.PhysBody.ptr);
-    }
-
-    // Routine called when rebuilding the body of some member of the linkset.
-    // Since we don't keep in world relationships, do nothing unless it's a child changing.
-    // Returns 'true' of something was actually removed and would need restoring
-    // Called at taint-time!!
-    public override bool RemoveBodyDependencies(BSPrim child)
-    {
-        bool ret = false;
-
-        DetailLog("{0},BSLinksetCompound.RemoveBodyDependencies,refreshIfChild,rID={1},rBody={2},isRoot={3}",
-                        child.LocalID, LinksetRoot.LocalID, LinksetRoot.PhysBody.ptr.ToString("X"), IsRoot(child));
-
-        if (!IsRoot(child))
-        {
-            // Cause the current shape to be freed and the new one to be built.
-            InternalRefresh(LinksetRoot);
-            ret = true;
-        }
-
-        return ret;
-    }
-
-    // Companion to RemoveBodyDependencies(). If RemoveBodyDependencies() returns 'true',
-    // this routine will restore the removed constraints.
-    // Called at taint-time!!
-    public override void RestoreBodyDependencies(BSPrim child)
-    {
-        // The Refresh operation queued by RemoveBodyDependencies() will build any missing constraints.
-    }
-
-    // ================================================================
-
-    // Add a new child to the linkset.
-    // Called while LinkActivity is locked.
-    protected override void AddChildToLinkset(BSPhysObject child)
-    {
-        if (!HasChild(child))
-        {
-            m_children.Add(child);
-
-            DetailLog("{0},BSLinksetCompound.AddChildToLinkset,call,child={1}", LinksetRoot.LocalID, child.LocalID);
-
-            // Cause constraints and assorted properties to be recomputed before the next simulation step.
-            InternalRefresh(LinksetRoot);
-        }
-        return;
-    }
-
-    // Remove the specified child from the linkset.
-    // Safe to call even if the child is not really in my linkset.
-    protected override void RemoveChildFromLinkset(BSPhysObject child)
-    {
-        if (m_children.Remove(child))
-        {
-            DetailLog("{0},BSLinksetCompound.RemoveChildFromLinkset,call,rID={1},rBody={2},cID={3},cBody={4}",
-                            child.LocalID,
-                            LinksetRoot.LocalID, LinksetRoot.PhysBody.ptr.ToString("X"),
-                            child.LocalID, child.PhysBody.ptr.ToString("X"));
-
-            // Cause the child's body to be rebuilt and thus restored to normal operation
-            child.ForceBodyShapeRebuild(false);
-
-            if (!HasAnyChildren)
-            {
-                // The linkset is now empty. The root needs rebuilding.
-                LinksetRoot.ForceBodyShapeRebuild(false);
-            }
-            else
-            {
-                // Schedule a rebuild of the linkset  before the next simulation tick.
-                InternalRefresh(LinksetRoot);
-            }
-        }
-        return;
-    }
-
-    // Called before the simulation step to make sure the compound based linkset
-    //    is all initialized.
-    // Constraint linksets are rebuilt every time.
-    // Note that this works for rebuilding just the root after a linkset is taken apart.
-    // Called at taint time!!
-    private void RecomputeLinksetCompound()
-    {
-        // Cause the root shape to be rebuilt as a compound object with just the root in it
-        LinksetRoot.ForceBodyShapeRebuild(true);
-
-        DetailLog("{0},BSLinksetCompound.RecomputeLinksetCompound,start,rBody={1},rShape={2},numChildren={3}",
-                        LinksetRoot.LocalID, LinksetRoot.PhysBody, LinksetRoot.PhysShape, NumberOfChildren);
-
-        // Add a shape for each of the other children in the linkset
-        ForEachMember(delegate(BSPhysObject cPrim)
-        {
-            if (!IsRoot(cPrim))
-            {
-                // Each child position and rotation is given relative to the root.
-                OMV.Quaternion invRootOrientation = OMV.Quaternion.Inverse(LinksetRoot.RawOrientation);
-                OMV.Vector3 displacementPos = (cPrim.RawPosition - LinksetRoot.RawPosition) * invRootOrientation;
-                OMV.Quaternion displacementRot = cPrim.RawOrientation * invRootOrientation;
-
-                DetailLog("{0},BSLinksetCompound.RecomputeLinksetCompound,addMemberToShape,mID={1},mShape={2},dispPos={3},dispRot={4}",
-                    LinksetRoot.LocalID, cPrim.LocalID, cPrim.PhysShape, displacementPos, displacementRot);
-
-                if (cPrim.PhysShape.isNativeShape)
-                {
-                    // Native shapes are not shared so we need to create a new one.
-                    // A mesh or hull is created because scale is not available on a native shape.
-                    //     (TODO: Bullet does have a btScaledCollisionShape. Can that be used?)
-                    BulletShape saveShape = cPrim.PhysShape;
-                    cPrim.PhysShape.ptr = IntPtr.Zero;  // Don't let the create free the child's shape
-                    PhysicsScene.Shapes.CreateGeomMeshOrHull(cPrim, null);
-                    BulletShape newShape = cPrim.PhysShape;
-                    cPrim.PhysShape = saveShape;
-                    BulletSimAPI.AddChildShapeToCompoundShape2(LinksetRoot.PhysShape.ptr, newShape.ptr, displacementPos, displacementRot);
-                }
-                else
-                {
-                    // For the shared shapes (meshes and hulls), just use the shape in the child.
-                    if (PhysicsScene.Shapes.ReferenceShape(cPrim.PhysShape))
-                    {
-                        PhysicsScene.Logger.ErrorFormat("{0} Rebuilt sharable shape when building linkset! Region={1}, primID={2}, shape={3}",
-                                            LogHeader, PhysicsScene.RegionName, cPrim.LocalID, cPrim.PhysShape);
-                    }
-                    BulletSimAPI.AddChildShapeToCompoundShape2(LinksetRoot.PhysShape.ptr, cPrim.PhysShape.ptr, displacementPos, displacementRot);
-                }
-            }
-            return false;   // 'false' says to move onto the next child in the list
-        });
-
-        // With all of the linkset packed into the root prim, it has the mass of everyone.
-        float linksetMass = LinksetMass;
-        LinksetRoot.UpdatePhysicalMassProperties(linksetMass);
-
-        // DEBUG: see of inter-linkset collisions are causing problems for constraint linksets.
-        // BulletSimAPI.SetCollisionFilterMask2(LinksetRoot.BSBody.ptr, 
-        //                     (uint)CollisionFilterGroups.LinksetFilter, (uint)CollisionFilterGroups.LinksetMask);
-
-    }
-}
-}
\ No newline at end of file
diff --git a/OpenSim/Region/Physics/BulletSPlugin/BSLinksetConstraints.cs b/OpenSim/Region/Physics/BulletSPlugin/BSLinksetConstraints.cs
deleted file mode 100755
index d2387fb..0000000
--- a/OpenSim/Region/Physics/BulletSPlugin/BSLinksetConstraints.cs
+++ /dev/null
@@ -1,327 +0,0 @@
-/*
- * Copyright (c) Contributors, http://opensimulator.org/
- * See CONTRIBUTORS.TXT for a full list of copyright holders.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *     * Redistributions of source code must retain the above copyright
- *       notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyrightD
- *       notice, this list of conditions and the following disclaimer in the
- *       documentation and/or other materials provided with the distribution.
- *     * Neither the name of the OpenSimulator Project nor the
- *       names of its contributors may be used to endorse or promote products
- *       derived from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
- * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
- * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-using System;
-using System.Collections.Generic;
-using System.Text;
-
-using OMV = OpenMetaverse;
-
-namespace OpenSim.Region.Physics.BulletSPlugin
-{
-public sealed class BSLinksetConstraints : BSLinkset
-{
-    // private static string LogHeader = "[BULLETSIM LINKSET CONSTRAINTS]";
-
-    public BSLinksetConstraints(BSScene scene, BSPhysObject parent)
-    {
-        base.Initialize(scene, parent);
-    }
-
-    // When physical properties are changed the linkset needs to recalculate
-    //   its internal properties.
-    // This is queued in the 'post taint' queue so the
-    //   refresh will happen once after all the other taints are applied.
-    public override void Refresh(BSPhysObject requestor)
-    {
-        // Queue to happen after all the other taint processing
-        PhysicsScene.PostTaintObject("BSLinksetContraints.Refresh", requestor.LocalID, delegate()
-            {
-                if (HasAnyChildren && IsRoot(requestor))
-                    RecomputeLinksetConstraints();
-            });
-    }
-
-    // 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.
-    // Return 'true' if any properties updated on the passed object.
-    // Called at taint-time!
-    public override bool MakeDynamic(BSPhysObject child)
-    {
-        // What is done for each object in BSPrim is what we want.
-        return false;
-    }
-
-    // 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.
-    // This doesn't normally happen -- OpenSim removes the objects from the physical
-    //     world if it is a static linkset.
-    // Called at taint-time!
-    public override bool MakeStatic(BSPhysObject child)
-    {
-        // What is done for each object in BSPrim is what we want.
-        return false;
-    }
-
-    // Called at taint-time!!
-    public override void UpdateProperties(BSPhysObject updated)
-    {
-        // Nothing to do for constraints on property updates
-    }
-
-    // The children of the linkset are moved around by the constraints.
-    // Just grab the current values of wherever it is right now.
-    public override OMV.Vector3 Position(BSPhysObject member)
-    {
-        return BulletSimAPI.GetPosition2(member.PhysBody.ptr);
-    }
-
-    public override OMV.Quaternion Orientation(BSPhysObject member)
-    {
-        return BulletSimAPI.GetOrientation2(member.PhysBody.ptr);
-    }
-
-    // Routine called when rebuilding the body of some member of the linkset.
-    // Destroy all the constraints have have been made to root and set
-    //     up to rebuild the constraints before the next simulation step.
-    // Returns 'true' of something was actually removed and would need restoring
-    // Called at taint-time!!
-    public override bool RemoveBodyDependencies(BSPrim child)
-    {
-        bool ret = false;
-
-        DetailLog("{0},BSLinksetConstraint.RemoveBodyDependencies,removeChildrenForRoot,rID={1},rBody={2}",
-                                    child.LocalID, LinksetRoot.LocalID, LinksetRoot.PhysBody.ptr.ToString("X"));
-
-        lock (m_linksetActivityLock)
-        {
-            // Just undo all the constraints for this linkset. Rebuild at the end of the step.
-            ret = PhysicallyUnlinkAllChildrenFromRoot(LinksetRoot);
-            // Cause the constraints, et al to be rebuilt before the next simulation step.
-            Refresh(LinksetRoot);
-        }
-        return ret;
-    }
-
-    // Companion to RemoveBodyDependencies(). If RemoveBodyDependencies() returns 'true',
-    // this routine will restore the removed constraints.
-    // Called at taint-time!!
-    public override void RestoreBodyDependencies(BSPrim child)
-    {
-        // The Refresh operation queued by RemoveBodyDependencies() will build any missing constraints.
-    }
-
-    // ================================================================
-
-    // Add a new child to the linkset.
-    // Called while LinkActivity is locked.
-    protected override void AddChildToLinkset(BSPhysObject child)
-    {
-        if (!HasChild(child))
-        {
-            m_children.Add(child);
-
-            DetailLog("{0},BSLinksetConstraints.AddChildToLinkset,call,child={1}", LinksetRoot.LocalID, child.LocalID);
-
-            // Cause constraints and assorted properties to be recomputed before the next simulation step.
-            Refresh(LinksetRoot);
-        }
-        return;
-    }
-
-    // Remove the specified child from the linkset.
-    // Safe to call even if the child is not really in my linkset.
-    protected override void RemoveChildFromLinkset(BSPhysObject child)
-    {
-        if (m_children.Remove(child))
-        {
-            BSPhysObject rootx = LinksetRoot; // capture the root and body as of now
-            BSPhysObject childx = child;
-
-            DetailLog("{0},BSLinksetConstraints.RemoveChildFromLinkset,call,rID={1},rBody={2},cID={3},cBody={4}",
-                            childx.LocalID,
-                            rootx.LocalID, rootx.PhysBody.ptr.ToString("X"),
-                            childx.LocalID, childx.PhysBody.ptr.ToString("X"));
-
-            PhysicsScene.TaintedObject("BSLinksetConstraints.RemoveChildFromLinkset", delegate()
-            {
-                PhysicallyUnlinkAChildFromRoot(rootx, childx);
-            });
-            // See that the linkset parameters are recomputed at the end of the taint time.
-            Refresh(LinksetRoot);
-        }
-        else
-        {
-            // Non-fatal occurance.
-            // PhysicsScene.Logger.ErrorFormat("{0}: Asked to remove child from linkset that was not in linkset", LogHeader);
-        }
-        return;
-    }
-
-    // Create a constraint between me (root of linkset) and the passed prim (the child).
-    // Called at taint time!
-    private void PhysicallyLinkAChildToRoot(BSPhysObject rootPrim, BSPhysObject childPrim)
-    {
-        // Don't build the constraint when asked. Put it off until just before the simulation step.
-        Refresh(rootPrim);
-    }
-
-    private BSConstraint BuildConstraint(BSPhysObject rootPrim, BSPhysObject childPrim)
-    {
-        // Zero motion for children so they don't interpolate
-        childPrim.ZeroMotion();
-
-        // Relative position normalized to the root prim
-        // Essentually a vector pointing from center of rootPrim to center of childPrim
-        OMV.Vector3 childRelativePosition = childPrim.Position - rootPrim.Position;
-
-        // real world coordinate of midpoint between the two objects
-        OMV.Vector3 midPoint = rootPrim.Position + (childRelativePosition / 2);
-
-        DetailLog("{0},BSLinksetConstraint.BuildConstraint,taint,root={1},rBody={2},child={3},cBody={4},rLoc={5},cLoc={6},midLoc={7}",
-                                        rootPrim.LocalID,
-                                        rootPrim.LocalID, rootPrim.PhysBody.ptr.ToString("X"),
-                                        childPrim.LocalID, childPrim.PhysBody.ptr.ToString("X"),
-                                        rootPrim.Position, childPrim.Position, midPoint);
-
-        // create a constraint that allows no freedom of movement between the two objects
-        // http://bulletphysics.org/Bullet/phpBB3/viewtopic.php?t=4818
-
-        BSConstraint6Dof constrain = new BSConstraint6Dof(
-                            PhysicsScene.World, rootPrim.PhysBody, childPrim.PhysBody, midPoint, true, true );
-                            // PhysicsScene.World, childPrim.BSBody, rootPrim.BSBody, midPoint, true, true );
-
-        /* NOTE: below is an attempt to build constraint with full frame computation, etc.
-         *     Using the midpoint is easier since it lets the Bullet code manipulate the transforms
-         *     of the objects.
-         * Code left for future programmers.
-        // ==================================================================================
-        // relative position normalized to the root prim
-        OMV.Quaternion invThisOrientation = OMV.Quaternion.Inverse(rootPrim.Orientation);
-        OMV.Vector3 childRelativePosition = (childPrim.Position - rootPrim.Position) * invThisOrientation;
-
-        // relative rotation of the child to the parent
-        OMV.Quaternion childRelativeRotation = invThisOrientation * childPrim.Orientation;
-        OMV.Quaternion inverseChildRelativeRotation = OMV.Quaternion.Inverse(childRelativeRotation);
-
-        DetailLog("{0},BSLinksetConstraint.PhysicallyLinkAChildToRoot,taint,root={1},child={2}", rootPrim.LocalID, rootPrim.LocalID, childPrim.LocalID);
-        BS6DofConstraint constrain = new BS6DofConstraint(
-                        PhysicsScene.World, rootPrim.Body, childPrim.Body,
-                        OMV.Vector3.Zero,
-                        OMV.Quaternion.Inverse(rootPrim.Orientation),
-                        OMV.Vector3.Zero,
-                        OMV.Quaternion.Inverse(childPrim.Orientation),
-                        true,
-                        true
-                        );
-        // ==================================================================================
-        */
-
-        PhysicsScene.Constraints.AddConstraint(constrain);
-
-        // zero linear and angular limits makes the objects unable to move in relation to each other
-        constrain.SetLinearLimits(OMV.Vector3.Zero, OMV.Vector3.Zero);
-        constrain.SetAngularLimits(OMV.Vector3.Zero, OMV.Vector3.Zero);
-
-        // tweek the constraint to increase stability
-        constrain.UseFrameOffset(PhysicsScene.BoolNumeric(PhysicsScene.Params.linkConstraintUseFrameOffset));
-        constrain.TranslationalLimitMotor(PhysicsScene.BoolNumeric(PhysicsScene.Params.linkConstraintEnableTransMotor),
-                        PhysicsScene.Params.linkConstraintTransMotorMaxVel,
-                        PhysicsScene.Params.linkConstraintTransMotorMaxForce);
-        constrain.SetCFMAndERP(PhysicsScene.Params.linkConstraintCFM, PhysicsScene.Params.linkConstraintERP);
-        if (PhysicsScene.Params.linkConstraintSolverIterations != 0f)
-        {
-            constrain.SetSolverIterations(PhysicsScene.Params.linkConstraintSolverIterations);
-        }
-        return constrain;
-    }
-
-    // Remove linkage between the linkset root and a particular child
-    // The root and child bodies are passed in because we need to remove the constraint between
-    //      the bodies that were present at unlink time.
-    // Called at taint time!
-    private bool PhysicallyUnlinkAChildFromRoot(BSPhysObject rootPrim, BSPhysObject childPrim)
-    {
-        bool ret = false;
-        DetailLog("{0},BSLinksetConstraint.PhysicallyUnlinkAChildFromRoot,taint,root={1},rBody={2},child={3},cBody={4}",
-                            rootPrim.LocalID,
-                            rootPrim.LocalID, rootPrim.PhysBody.ptr.ToString("X"),
-                            childPrim.LocalID, childPrim.PhysBody.ptr.ToString("X"));
-
-        // Find the constraint for this link and get rid of it from the overall collection and from my list
-        if (PhysicsScene.Constraints.RemoveAndDestroyConstraint(rootPrim.PhysBody, childPrim.PhysBody))
-        {
-            // Make the child refresh its location
-            BulletSimAPI.PushUpdate2(childPrim.PhysBody.ptr);
-            ret = true;
-        }
-
-        return ret;
-    }
-
-    // Remove linkage between myself and any possible children I might have.
-    // Returns 'true' of any constraints were destroyed.
-    // Called at taint time!
-    private bool PhysicallyUnlinkAllChildrenFromRoot(BSPhysObject rootPrim)
-    {
-        DetailLog("{0},BSLinksetConstraint.PhysicallyUnlinkAllChildren,taint", rootPrim.LocalID);
-
-        return PhysicsScene.Constraints.RemoveAndDestroyConstraint(rootPrim.PhysBody);
-    }
-
-    // Call each of the constraints that make up this linkset and recompute the
-    //    various transforms and variables. Create constraints of not created yet.
-    // Called before the simulation step to make sure the constraint based linkset
-    //    is all initialized.
-    // Called at taint time!!
-    private void RecomputeLinksetConstraints()
-    {
-        float linksetMass = LinksetMass;
-        LinksetRoot.UpdatePhysicalMassProperties(linksetMass);
-
-        // DEBUG: see of inter-linkset collisions are causing problems
-        // BulletSimAPI.SetCollisionFilterMask2(LinksetRoot.BSBody.ptr, 
-        //                     (uint)CollisionFilterGroups.LinksetFilter, (uint)CollisionFilterGroups.LinksetMask);
-        DetailLog("{0},BSLinksetConstraint.RecomputeLinksetConstraints,set,rBody={1},linksetMass={2}",
-                            LinksetRoot.LocalID, LinksetRoot.PhysBody.ptr.ToString("X"), linksetMass);
-
-        foreach (BSPhysObject child in m_children)
-        {
-            // A child in the linkset physically shows the mass of the whole linkset.
-            // This allows Bullet to apply enough force on the child to move the whole linkset.
-            // (Also do the mass stuff before recomputing the constraint so mass is not zero.)
-            child.UpdatePhysicalMassProperties(linksetMass);
-
-            BSConstraint constrain;
-            if (!PhysicsScene.Constraints.TryGetConstraint(LinksetRoot.PhysBody, child.PhysBody, out constrain))
-            {
-                // If constraint doesn't exist yet, create it.
-                constrain = BuildConstraint(LinksetRoot, child);
-            }
-            constrain.RecomputeConstraintVariables(linksetMass);
-
-            // DEBUG: see of inter-linkset collisions are causing problems
-            // BulletSimAPI.SetCollisionFilterMask2(child.BSBody.ptr, 
-            //                 (uint)CollisionFilterGroups.LinksetFilter, (uint)CollisionFilterGroups.LinksetMask);
-
-            // BulletSimAPI.DumpConstraint2(PhysicsScene.World.ptr, constrain.Constraint.ptr);    // DEBUG DEBUG
-        }
-
-    }
-}
-}
diff --git a/OpenSim/Region/Physics/BulletSPlugin/BSPhysObject.cs b/OpenSim/Region/Physics/BulletSPlugin/BSPhysObject.cs
deleted file mode 100755
index 7127aaf..0000000
--- a/OpenSim/Region/Physics/BulletSPlugin/BSPhysObject.cs
+++ /dev/null
@@ -1,248 +0,0 @@
-/*
- * Copyright (c) Contributors, http://opensimulator.org/
- * See CONTRIBUTORS.TXT for a full list of copyright holders.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *     * Redistributions of source code must retain the above copyright
- *       notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyrightD
- *       notice, this list of conditions and the following disclaimer in the
- *       documentation and/or other materials provided with the distribution.
- *     * Neither the name of the OpenSimulator Project nor the
- *       names of its contributors may be used to endorse or promote products
- *       derived from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
- * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
- * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-using System;
-using System.Collections.Generic;
-using System.Text;
-
-using OMV = OpenMetaverse;
-using OpenSim.Framework;
-using OpenSim.Region.Physics.Manager;
-
-namespace OpenSim.Region.Physics.BulletSPlugin
-{
-// Class to wrap all objects.
-// The rest of BulletSim doesn't need to keep checking for avatars or prims
-// unless the difference is significant.
-public abstract class BSPhysObject : PhysicsActor
-{
-    protected void BaseInitialize(BSScene parentScene, uint localID, string name, string typeName)
-    {
-        PhysicsScene = parentScene;
-        LocalID = localID;
-        PhysObjectName = name;
-        TypeName = typeName;
-
-        Linkset = BSLinkset.Factory(PhysicsScene, this);
-        LastAssetBuildFailed = false;
-
-        CollisionCollection = new CollisionEventUpdate();
-        SubscribedEventsMs = 0;
-        CollidingStep = 0;
-        CollidingGroundStep = 0;
-    }
-
-    public BSScene PhysicsScene { get; protected set; }
-    // public override uint LocalID { get; set; } // Use the LocalID definition in PhysicsActor
-    public string PhysObjectName { get; protected set; }
-    public string TypeName { get; protected set; }
-
-    public BSLinkset Linkset { get; set; }
-
-    // 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, ...)
-    public abstract void UpdatePhysicalMassProperties(float mass);
-
-    // Reference to the physical body (btCollisionObject) of this object
-    public BulletBody PhysBody;
-    // Reference to the physical shape (btCollisionShape) of this object
-    public BulletShape PhysShape;
-
-    // 'true' if the mesh's underlying asset failed to build.
-    // This will keep us from looping after the first time the build failed.
-    public bool LastAssetBuildFailed { get; set; }
-
-    // The objects base shape information. Null if not a prim type shape.
-    public PrimitiveBaseShape BaseShape { get; protected set; }
-    // Some types of objects have preferred physical representations.
-    // Returns SHAPE_UNKNOWN if there is no preference.
-    public virtual ShapeData.PhysicsShapeType PreferredPhysicalShape
-    {
-        get { return ShapeData.PhysicsShapeType.SHAPE_UNKNOWN; }
-    }
-
-    // When the physical properties are updated, an EntityProperty holds the update values.
-    // Keep the current and last EntityProperties to enable computation of differences
-    //      between the current update and the previous values.
-    public EntityProperties CurrentEntityProperties { get; set; }
-    public EntityProperties LastEntityProperties { get; set; }
-
-    public abstract OMV.Vector3 Scale { get; set; }
-    public abstract bool IsSolid { get; }
-    public abstract bool IsStatic { get; }
-
-    // Stop all physical motion.
-    public abstract void ZeroMotion();
-
-    // Step the vehicle simulation for this object. A NOOP if the vehicle was not configured.
-    public virtual void StepVehicle(float timeStep) { }
-
-    // Update the physical location and motion of the object. Called with data from Bullet.
-    public abstract void UpdateProperties(EntityProperties entprop);
-
-    // Tell the object to clean up.
-    public abstract void Destroy();
-
-    public abstract OMV.Vector3 RawPosition { get; set; }
-    public abstract OMV.Vector3 ForcePosition { get; set; }
-
-    public abstract OMV.Quaternion RawOrientation { get; set; }
-    public abstract OMV.Quaternion ForceOrientation { get; set; }
-
-    public abstract OMV.Vector3 ForceVelocity { get; set; }
-
-    public abstract OMV.Vector3 ForceRotationalVelocity { get; set; }
-
-    public abstract float ForceBuoyancy { get; set; }
-
-    public virtual bool ForceBodyShapeRebuild(bool inTaintTime) { return false; }
-
-    #region Collisions
-
-    // Requested number of milliseconds between collision events. Zero means disabled.
-    protected int SubscribedEventsMs { get; set; }
-    // Given subscription, the time that a collision may be passed up
-    protected int NextCollisionOkTime { get; set; }
-    // The simulation step that last had a collision
-    protected long CollidingStep { get; set; }
-    // The simulation step that last had a collision with the ground
-    protected long CollidingGroundStep { get; set; }
-    // The collision flags we think are set in Bullet
-    protected CollisionFlags CurrentCollisionFlags { get; set; }
-
-    // The collisions that have been collected this tick
-    protected CollisionEventUpdate CollisionCollection;
-
-    // The simulation step is telling this object about a collision.
-    // Return 'true' if a collision was processed and should be sent up.
-    // Called at taint time from within the Step() function
-    public virtual bool Collide(uint collidingWith, BSPhysObject collidee,
-                    OMV.Vector3 contactPoint, OMV.Vector3 contactNormal, float pentrationDepth)
-    {
-        bool ret = false;
-
-        // The following lines make IsColliding() and IsCollidingGround() work
-        CollidingStep = PhysicsScene.SimulationStep;
-        if (collidingWith <= PhysicsScene.TerrainManager.HighestTerrainID)
-        {
-            CollidingGroundStep = PhysicsScene.SimulationStep;
-        }
-
-        // prims in the same linkset cannot collide with each other
-        if (collidee != null && (this.Linkset.LinksetID == collidee.Linkset.LinksetID))
-        {
-            return ret;
-        }
-
-        // if someone has subscribed for collision events....
-        if (SubscribedEvents()) {
-            CollisionCollection.AddCollider(collidingWith, new ContactPoint(contactPoint, contactNormal, pentrationDepth));
-            DetailLog("{0},{1}.Collison.AddCollider,call,with={2},point={3},normal={4},depth={5}",
-                            LocalID, TypeName, collidingWith, contactPoint, contactNormal, pentrationDepth);
-
-            ret = true;
-        }
-        return ret;
-    }
-
-    // Send the collected collisions into the simulator.
-    // Called at taint time from within the Step() function thus no locking problems
-    //      with CollisionCollection and ObjectsWithNoMoreCollisions.
-    // 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
-        bool force = CollisionCollection.Count == 0;
-
-        // throttle the collisions to the number of milliseconds specified in the subscription
-        if (force || (PhysicsScene.SimulationNowTime >= NextCollisionOkTime))
-        {
-            NextCollisionOkTime = PhysicsScene.SimulationNowTime + SubscribedEventsMs;
-
-            // We are called if we previously had collisions. If there are no collisions
-            //   this time, send up one last empty event so OpenSim can sense collision end.
-            if (CollisionCollection.Count == 0)
-            {
-                // If I have no collisions this time, remove me from the list of objects with collisions.
-                ret = false;
-            }
-
-            // DetailLog("{0},{1}.SendCollisionUpdate,call,numCollisions={2}", LocalID, TypeName, CollisionCollection.Count);
-            base.SendCollisionUpdate(CollisionCollection);
-
-            // The collisionCollection structure is passed around in the simulator.
-            // Make sure we don't have a handle to that one and that a new one is used for next time.
-            CollisionCollection = new CollisionEventUpdate();
-        }
-        return ret;
-    }
-
-    // Subscribe for collision events.
-    // Parameter is the millisecond rate the caller wishes collision events to occur.
-    public override void SubscribeEvents(int ms) {
-        // DetailLog("{0},{1}.SubscribeEvents,subscribing,ms={2}", LocalID, TypeName, ms);
-        SubscribedEventsMs = ms;
-        if (ms > 0)
-        {
-            // make sure first collision happens
-            NextCollisionOkTime = Util.EnvironmentTickCountSubtract(SubscribedEventsMs);
-
-            PhysicsScene.TaintedObject(TypeName+".SubscribeEvents", delegate()
-            {
-                CurrentCollisionFlags = BulletSimAPI.AddToCollisionFlags2(PhysBody.ptr, CollisionFlags.BS_SUBSCRIBE_COLLISION_EVENTS);
-            });
-        }
-        else
-        {
-            // Subscribing for zero or less is the same as unsubscribing
-            UnSubscribeEvents();
-        }
-    }
-    public override void UnSubscribeEvents() {
-        // DetailLog("{0},{1}.UnSubscribeEvents,unsubscribing", LocalID, TypeName);
-        SubscribedEventsMs = 0;
-        PhysicsScene.TaintedObject(TypeName+".UnSubscribeEvents", delegate()
-        {
-            CurrentCollisionFlags = BulletSimAPI.RemoveFromCollisionFlags2(PhysBody.ptr, CollisionFlags.BS_SUBSCRIBE_COLLISION_EVENTS);
-        });
-    }
-    // Return 'true' if the simulator wants collision events
-    public override bool SubscribedEvents() {
-        return (SubscribedEventsMs > 0);
-    }
-
-    #endregion // Collisions
-
-    // High performance detailed logging routine used by the physical objects.
-    protected void DetailLog(string msg, params Object[] args)
-    {
-        if (PhysicsScene.PhysicsLogging.Enabled)
-            PhysicsScene.DetailLog(msg, args);
-    }
-}
-}
diff --git a/OpenSim/Region/Physics/BulletSPlugin/BSPlugin.cs b/OpenSim/Region/Physics/BulletSPlugin/BSPlugin.cs
index 20f5180..0f027b8 100644
--- a/OpenSim/Region/Physics/BulletSPlugin/BSPlugin.cs
+++ b/OpenSim/Region/Physics/BulletSPlugin/BSPlugin.cs
@@ -33,7 +33,7 @@ using OpenMetaverse;
 namespace OpenSim.Region.Physics.BulletSPlugin
 {
     /// <summary>
-    /// Entry for a port of Bullet (http://bulletphysics.org/) to OpenSim.
+    /// Entry for a port of Bullet (http://bulletphysics.org/) to OpenSim. 
     /// This module interfaces to an unmanaged C++ library which makes the
     /// actual calls into the Bullet physics engine.
     /// The unmanaged library is found in opensim-libs::trunk/unmanaged/BulletSim/.
@@ -62,7 +62,7 @@ public class BSPlugin : IPhysicsPlugin
             if (Util.IsWindows())
                 Util.LoadArchSpecificWindowsDll("BulletSim.dll");
             // If not Windows, loading is performed by the
-            // Mono loader as specified in
+            // Mono loader as specified in 
             // "bin/Physics/OpenSim.Region.Physics.BulletSPlugin.dll.config".
 
             _mScene = new BSScene(sceneIdentifier);
diff --git a/OpenSim/Region/Physics/BulletSPlugin/BSPrim.cs b/OpenSim/Region/Physics/BulletSPlugin/BSPrim.cs
index aaa0d93..9c20004 100644
--- a/OpenSim/Region/Physics/BulletSPlugin/BSPrim.cs
+++ b/OpenSim/Region/Physics/BulletSPlugin/BSPrim.cs
@@ -24,9 +24,6 @@
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
-
-// Uncomment this it enable code to do all shape an body memory management
-//    in the C# code.
 using System;
 using System.Reflection;
 using System.Collections.Generic;
@@ -39,18 +36,32 @@ using OpenSim.Region.Physics.ConvexDecompositionDotNet;
 
 namespace OpenSim.Region.Physics.BulletSPlugin
 {
-
     [Serializable]
-public sealed class BSPrim : BSPhysObject
+public sealed class BSPrim : PhysicsActor
 {
     private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
     private static readonly string LogHeader = "[BULLETS PRIM]";
 
-    // _size is what the user passed. Scale is what we pass to the physics engine with the mesh.
-    // Often Scale is unity because the meshmerizer will apply _size when creating the mesh.
+    private void DebugLog(string mm, params Object[] xx) { if (_scene.ShouldDebugLog) m_log.DebugFormat(mm, xx); }
+
+    private IMesh _mesh;
+    private PrimitiveBaseShape _pbs;
+    private ShapeData.PhysicsShapeType _shapeType;
+    private ulong _meshKey;
+    private ulong _hullKey;
+    private List<ConvexResult> _hulls;
+
+    private BSScene _scene;
+    public BSScene Scene { get { return _scene; } }
+    private String _avName;
+    private uint _localID = 0;
+
+    // _size is what the user passed. _scale is what we pass to the physics engine with the mesh.
+    // Often _scale is unity because the meshmerizer will apply _size when creating the mesh.
     private OMV.Vector3 _size;  // the multiplier for each mesh dimension as passed by the user
-    // private OMV.Vector3 _scale; // the multiplier for each mesh dimension for the mesh as created by the meshmerizer
+    private OMV.Vector3 _scale; // the multiplier for each mesh dimension for the mesh as created by the meshmerizer
 
+    private bool _stopped;
     private bool _grabbed;
     private bool _isSelected;
     private bool _isVolumeDetect;
@@ -78,6 +89,25 @@ public sealed class BSPrim : BSPhysObject
     private bool _kinematic;
     private float _buoyancy;
 
+    // Membership in a linkset is controlled by this class.
+    private BSLinkset _linkset;
+    public BSLinkset Linkset
+    {
+        get { return _linkset; }
+        set { _linkset = value; }
+    }
+
+    private int _subscribedEventsMs = 0;
+    private int _nextCollisionOkTime = 0;
+    long _collidingStep;
+    long _collidingGroundStep;
+
+    private BulletBody m_body;
+    public BulletBody Body { 
+        get { return m_body; }
+        set { m_body = value; }
+    }
+
     private BSDynamics _vehicle;
 
     private OMV.Vector3 _PIDTarget;
@@ -92,112 +122,108 @@ public sealed class BSPrim : BSPhysObject
                        OMV.Quaternion rotation, PrimitiveBaseShape pbs, bool pisPhysical)
     {
         // m_log.DebugFormat("{0}: BSPrim creation of {1}, id={2}", LogHeader, primName, localID);
-        base.BaseInitialize(parent_scene, localID, primName, "BSPrim");
-        _physicsActorType = (int)ActorTypes.Prim;
+        _localID = localID;
+        _avName = primName;
+        _scene = parent_scene;
         _position = pos;
         _size = size;
-        Scale = new OMV.Vector3(1f, 1f, 1f);   // the scale will be set by CreateGeom depending on object type
+        _scale = new OMV.Vector3(1f, 1f, 1f);   // the scale will be set by CreateGeom depending on object type
         _orientation = rotation;
         _buoyancy = 1f;
         _velocity = OMV.Vector3.Zero;
         _rotationalVelocity = OMV.Vector3.Zero;
-        BaseShape = pbs;
+        _hullKey = 0;
+        _meshKey = 0;
+        _pbs = pbs;
         _isPhysical = pisPhysical;
         _isVolumeDetect = false;
-        _friction = PhysicsScene.Params.defaultFriction;  // TODO: compute based on object material
-        _density = PhysicsScene.Params.defaultDensity;    // TODO: compute based on object material
-        _restitution = PhysicsScene.Params.defaultRestitution;
-        _vehicle = new BSDynamics(PhysicsScene, this);            // add vehicleness
+        _subscribedEventsMs = 0;
+        _friction = _scene.Params.defaultFriction;  // TODO: compute based on object material
+        _density = _scene.Params.defaultDensity;    // TODO: compute based on object material
+        _restitution = _scene.Params.defaultRestitution;
+        _linkset = new BSLinkset(_scene, this);     // a linkset of one
+        _vehicle = new BSDynamics(this);            // add vehicleness
         _mass = CalculateMass();
-
-        // No body or shape yet
-        PhysBody = new BulletBody(LocalID, IntPtr.Zero);
-        PhysShape = new BulletShape(IntPtr.Zero);
-
-        DetailLog("{0},BSPrim.constructor,call", LocalID);
         // do the actual object creation at taint time
-        PhysicsScene.TaintedObject("BSPrim.create", delegate()
+        DetailLog("{0},BSPrim.constructor,call", LocalID);
+        _scene.TaintedObject("BSPrim.create", delegate()
         {
-            CreateGeomAndObject(true);
+            RecreateGeomAndObject();
 
-            CurrentCollisionFlags = BulletSimAPI.GetCollisionFlags2(PhysBody.ptr);
+            // Get the pointer to the physical body for this object.
+            // At the moment, we're still letting BulletSim manage the creation and destruction
+            //    of the object. Someday we'll move that into the C# code.
+            m_body = new BulletBody(LocalID, BulletSimAPI.GetBodyHandle2(_scene.World.Ptr, LocalID));
         });
     }
 
     // called when this prim is being destroyed and we should free all the resources
-    public override void Destroy()
+    public void Destroy()
     {
         // m_log.DebugFormat("{0}: Destroy, id={1}", LogHeader, LocalID);
 
         // Undo any links between me and any other object
-        BSPhysObject parentBefore = Linkset.LinksetRoot;
-        int childrenBefore = Linkset.NumberOfChildren;
+        BSPrim parentBefore = _linkset.LinksetRoot;
+        int childrenBefore = _linkset.NumberOfChildren;
 
-        Linkset = Linkset.RemoveMeFromLinkset(this);
+        _linkset = _linkset.RemoveMeFromLinkset(this);
 
         DetailLog("{0},BSPrim.Destroy,call,parentBefore={1},childrenBefore={2},parentAfter={3},childrenAfter={4}",
-            LocalID, parentBefore.LocalID, childrenBefore, Linkset.LinksetRoot.LocalID, Linkset.NumberOfChildren);
+            LocalID, parentBefore.LocalID, childrenBefore, _linkset.LinksetRoot.LocalID, _linkset.NumberOfChildren);
 
         // Undo any vehicle properties
         this.VehicleType = (int)Vehicle.TYPE_NONE;
 
-        PhysicsScene.TaintedObject("BSPrim.destroy", delegate()
+        _scene.TaintedObject("BSPrim.destroy", delegate()
         {
             DetailLog("{0},BSPrim.Destroy,taint,", LocalID);
-            // If there are physical body and shape, release my use of same.
-            PhysicsScene.Shapes.DereferenceBody(PhysBody, true, null);
-            PhysicsScene.Shapes.DereferenceShape(PhysShape, true, null);
+            // everything in the C# world will get garbage collected. Tell the C++ world to free stuff.
+            BulletSimAPI.DestroyObject(_scene.WorldID, LocalID);
         });
     }
-
-    // No one uses this property.
-    public override bool Stopped {
-        get { return false; }
+    
+    public override bool Stopped { 
+        get { return _stopped; } 
     }
-    public override OMV.Vector3 Size {
-        get { return _size; }
+    public override OMV.Vector3 Size { 
+        get { return _size; } 
         set {
             _size = value;
-            ForceBodyShapeRebuild(false);
-        }
+            _scene.TaintedObject("BSPrim.setSize", delegate()
+            {
+                _mass = CalculateMass();   // changing size changes the mass
+                BulletSimAPI.SetObjectScaleMass(_scene.WorldID, _localID, _scale, (IsPhysical ? _mass : 0f), IsPhysical);
+                // DetailLog("{0}: BSPrim.setSize: size={1}, mass={2}, physical={3}", LocalID, _size, _mass, IsPhysical);
+                RecreateGeomAndObject();
+            });
+        } 
     }
-    // Scale is what we set in the physics engine. It is different than 'size' in that
-    //     'size' can be encorporated into the mesh. In that case, the scale is <1,1,1>.
-    public override OMV.Vector3 Scale { get; set; }
-
-    public override PrimitiveBaseShape Shape {
+    public override PrimitiveBaseShape Shape { 
         set {
-            BaseShape = value;
-            ForceBodyShapeRebuild(false);
-        }
+            _pbs = value;
+            _scene.TaintedObject("BSPrim.setShape", delegate()
+            {
+                _mass = CalculateMass();   // changing the shape changes the mass
+                RecreateGeomAndObject();
+            });
+        } 
     }
-    // Whatever the linkset wants is what I want.
-    public override ShapeData.PhysicsShapeType PreferredPhysicalShape
-        { get { return Linkset.PreferredPhysicalShape(this); } }
-
-    public override bool ForceBodyShapeRebuild(bool inTaintTime)
-    {
-        LastAssetBuildFailed = false;
-        PhysicsScene.TaintedObject(inTaintTime, "BSPrim.ForceBodyShapeRebuild", delegate()
-        {
-            _mass = CalculateMass();   // changing the shape changes the mass
-            CreateGeomAndObject(true);
-        });
-        return true;
+    public override uint LocalID { 
+        set { _localID = value; }
+        get { return _localID; }
     }
-    public override bool Grabbed {
-        set { _grabbed = value;
-        }
+    public override bool Grabbed { 
+        set { _grabbed = value; 
+        } 
     }
-    public override bool Selected {
+    public override bool Selected { 
         set {
             _isSelected = value;
-            PhysicsScene.TaintedObject("BSPrim.setSelected", delegate()
+            _scene.TaintedObject("BSPrim.setSelected", delegate()
             {
-                DetailLog("{0},BSPrim.selected,taint,selected={1}", LocalID, _isSelected);
-                SetObjectDynamic(false);
+                SetObjectDynamic();
             });
-        }
+        } 
     }
     public override void CrossingFailure() { return; }
 
@@ -206,255 +232,158 @@ public sealed class BSPrim : BSPhysObject
         BSPrim parent = obj as BSPrim;
         if (parent != null)
         {
-            BSPhysObject parentBefore = Linkset.LinksetRoot;
-            int childrenBefore = Linkset.NumberOfChildren;
+            DebugLog("{0}: link {1}/{2} to {3}", LogHeader, _avName, _localID, parent.LocalID);
+            BSPrim parentBefore = _linkset.LinksetRoot;
+            int childrenBefore = _linkset.NumberOfChildren;
 
-            Linkset = parent.Linkset.AddMeToLinkset(this);
+            _linkset = parent.Linkset.AddMeToLinkset(this);
 
-            DetailLog("{0},BSPrim.link,call,parentBefore={1}, childrenBefore=={2}, parentAfter={3}, childrenAfter={4}",
-                LocalID, parentBefore.LocalID, childrenBefore, Linkset.LinksetRoot.LocalID, Linkset.NumberOfChildren);
+            DetailLog("{0},BSPrim.link,call,parentBefore={1}, childrenBefore=={2}, parentAfter={3}, childrenAfter={4}", 
+                LocalID, parentBefore.LocalID, childrenBefore, _linkset.LinksetRoot.LocalID, _linkset.NumberOfChildren);
         }
-        return;
+        return; 
     }
 
     // delink me from my linkset
     public override void delink() {
         // TODO: decide if this parent checking needs to happen at taint time
         // Race condition here: if link() and delink() in same simulation tick, the delink will not happen
+        DebugLog("{0}: delink {1}/{2}. Parent={3}", LogHeader, _avName, _localID, 
+                            _linkset.LinksetRoot._avName+"/"+_linkset.LinksetRoot.LocalID.ToString());
 
-        BSPhysObject parentBefore = Linkset.LinksetRoot;
-        int childrenBefore = Linkset.NumberOfChildren;
+        BSPrim parentBefore = _linkset.LinksetRoot;
+        int childrenBefore = _linkset.NumberOfChildren;
+        
+        _linkset = _linkset.RemoveMeFromLinkset(this);
 
-        Linkset = Linkset.RemoveMeFromLinkset(this);
-
-        DetailLog("{0},BSPrim.delink,parentBefore={1},childrenBefore={2},parentAfter={3},childrenAfter={4}, ",
-            LocalID, parentBefore.LocalID, childrenBefore, Linkset.LinksetRoot.LocalID, Linkset.NumberOfChildren);
-        return;
+        DetailLog("{0},BSPrim.delink,parentBefore={1},childrenBefore={2},parentAfter={3},childrenAfter={4}, ", 
+            LocalID, parentBefore.LocalID, childrenBefore, _linkset.LinksetRoot.LocalID, _linkset.NumberOfChildren);
+        return; 
     }
 
     // Set motion values to zero.
     // Do it to the properties so the values get set in the physics engine.
     // Push the setting of the values to the viewer.
     // Called at taint time!
-    public override void ZeroMotion()
+    public void ZeroMotion()
     {
         _velocity = OMV.Vector3.Zero;
         _acceleration = OMV.Vector3.Zero;
         _rotationalVelocity = OMV.Vector3.Zero;
 
-        // Zero some other properties in the physics engine
-        BulletSimAPI.ClearAllForces2(PhysBody.ptr);
+        // Zero some other properties directly into the physics engine
+        BulletSimAPI.SetVelocity2(Body.Ptr, OMV.Vector3.Zero);
+        BulletSimAPI.SetAngularVelocity2(Body.Ptr, OMV.Vector3.Zero);
+        BulletSimAPI.SetInterpolation2(Body.Ptr, OMV.Vector3.Zero, OMV.Vector3.Zero);
+        BulletSimAPI.ClearForces2(Body.Ptr);
     }
 
     public override void LockAngularMotion(OMV.Vector3 axis)
-    {
-        DetailLog("{0},BSPrim.LockAngularMotion,call,axis={1}", LocalID, axis);
+    { 
+        // DetailLog("{0},BSPrim.LockAngularMotion,call,axis={1}", LocalID, axis);
         return;
     }
 
-    public override OMV.Vector3 RawPosition
-    {
-        get { return _position; }
-        set { _position = value; }
-    }
-    public override OMV.Vector3 Position {
-        get {
-            // child prims move around based on their parent. Need to get the latest location
-            if (!Linkset.IsRoot(this))
-                _position = Linkset.Position(this);
+    public override OMV.Vector3 Position { 
+        get { 
+            if (!_linkset.IsRoot(this))
+                // child prims move around based on their parent. Need to get the latest location
+                _position = BulletSimAPI.GetObjectPosition(_scene.WorldID, _localID);
 
             // don't do the GetObjectPosition for root elements because this function is called a zillion times
-            // _position = BulletSimAPI.GetObjectPosition2(PhysicsScene.World.ptr, BSBody.ptr);
-            return _position;
-        }
+            // _position = BulletSimAPI.GetObjectPosition(_scene.WorldID, _localID);
+            return _position; 
+        } 
         set {
-            // If you must push the position into the physics engine, use ForcePosition.
-            if (_position == value)
-            {
-                return;
-            }
             _position = value;
             // TODO: what does it mean to set the position of a child prim?? Rebuild the constraint?
-            PositionSanityCheck();
-            PhysicsScene.TaintedObject("BSPrim.setPosition", delegate()
+            _scene.TaintedObject("BSPrim.setPosition", delegate()
             {
                 // DetailLog("{0},BSPrim.SetPosition,taint,pos={1},orient={2}", LocalID, _position, _orientation);
-                BulletSimAPI.SetTranslation2(PhysBody.ptr, _position, _orientation);
-                ActivateIfPhysical(false);
-            });
-        }
-    }
-    public override OMV.Vector3 ForcePosition {
-        get {
-            _position = BulletSimAPI.GetPosition2(PhysBody.ptr);
-            return _position;
-        }
-        set {
-            _position = value;
-            PositionSanityCheck();
-            BulletSimAPI.SetTranslation2(PhysBody.ptr, _position, _orientation);
-            ActivateIfPhysical(false);
-        }
-    }
-
-    // Check that the current position is sane and, if not, modify the position to make it so.
-    // Check for being below terrain and being out of bounds.
-    // Returns 'true' of the position was made sane by some action.
-    private bool PositionSanityCheck()
-    {
-        bool ret = false;
-
-        // If totally below the ground, move the prim up
-        // TODO: figure out the right solution for this... only for dynamic objects?
-        /*
-        float terrainHeight = PhysicsScene.TerrainManager.GetTerrainHeightAtXYZ(_position);
-        if (Position.Z < terrainHeight)
-        {
-            DetailLog("{0},BSPrim.PositionAdjustUnderGround,call,pos={1},terrain={2}", LocalID, _position, terrainHeight);
-            _position.Z = terrainHeight + 2.0f;
-            ret = true;
-        }
-         */
-        if ((CurrentCollisionFlags & CollisionFlags.BS_FLOATS_ON_WATER) != 0)
-        {
-            float waterHeight = PhysicsScene.GetWaterLevelAtXYZ(_position);
-            // TODO: a floating motor so object will bob in the water
-            if (Position.Z < waterHeight)
-            {
-                _position.Z = waterHeight;
-                ret = true;
-            }
-        }
-
-        // TODO: check for out of bounds
-        return ret;
-    }
-
-    // A version of the sanity check that also makes sure a new position value is
-    //    pushed to the physics engine. This routine would be used by anyone
-    //    who is not already pushing the value.
-    private bool PositionSanityCheck(bool inTaintTime)
-    {
-        bool ret = false;
-        if (PositionSanityCheck())
-        {
-            // The new position value must be pushed into the physics engine but we can't
-            //    just assign to "Position" because of potential call loops.
-            PhysicsScene.TaintedObject(inTaintTime, "BSPrim.PositionSanityCheck", delegate()
-            {
-                DetailLog("{0},BSPrim.PositionSanityCheck,taint,pos={1},orient={2}", LocalID, _position, _orientation);
-                ForcePosition = _position;
+                BulletSimAPI.SetObjectTranslation(_scene.WorldID, _localID, _position, _orientation);
             });
-            ret = true;
-        }
-        return ret;
+        } 
     }
 
     // Return the effective mass of the object.
     // If there are multiple items in the linkset, add them together for the root
     public override float Mass
-    {
+    { 
         get
         {
-            return Linkset.LinksetMass;
-            // return _mass;
+            return _linkset.LinksetMass;
         }
     }
 
     // used when we only want this prim's mass and not the linkset thing
-    public override float RawMass { 
-        get { return _mass; }
-    }
-    // Set the physical mass to the passed mass.
-    // Note that this does not change _mass!
-    public override void UpdatePhysicalMassProperties(float physMass)
-    {
-        if (IsStatic)
-        {
-            BulletSimAPI.SetMassProps2(PhysBody.ptr, 0f, OMV.Vector3.Zero);
-            BulletSimAPI.UpdateInertiaTensor2(PhysBody.ptr);
-        }
-        else
-        {
-            OMV.Vector3 localInertia = BulletSimAPI.CalculateLocalInertia2(PhysShape.ptr, physMass);
-            BulletSimAPI.SetMassProps2(PhysBody.ptr, physMass, localInertia);
-            // center of mass is at the zero of the object
-            BulletSimAPI.SetCenterOfMassByPosRot2(PhysBody.ptr, ForcePosition, ForceOrientation);
-            // BulletSimAPI.UpdateInertiaTensor2(BSBody.ptr);
-            DetailLog("{0},BSPrim.UpdateMassProperties,mass={1},localInertia={2}", LocalID, physMass, localInertia);
-        }
-    }
+    public float MassRaw { get { return _mass; } }
 
     // Is this used?
     public override OMV.Vector3 CenterOfMass
     {
-        get { return Linkset.CenterOfMass; }
+        get { return _linkset.CenterOfMass; }
     }
 
     // Is this used?
     public override OMV.Vector3 GeometricCenter
     {
-        get { return Linkset.GeometricCenter; }
+        get { return _linkset.GeometricCenter; }
     }
 
-    public override OMV.Vector3 Force {
-        get { return _force; }
+    public override OMV.Vector3 Force { 
+        get { return _force; } 
         set {
             _force = value;
-            PhysicsScene.TaintedObject("BSPrim.setForce", delegate()
+            _scene.TaintedObject("BSPrim.setForce", delegate()
             {
                 // DetailLog("{0},BSPrim.setForce,taint,force={1}", LocalID, _force);
-                BulletSimAPI.SetObjectForce2(PhysBody.ptr, _force);
+                // BulletSimAPI.SetObjectForce(_scene.WorldID, _localID, _force);
+                BulletSimAPI.SetObjectForce2(Body.Ptr, _force);
             });
-        }
+        } 
     }
 
-    public override int VehicleType {
+    public override int VehicleType { 
         get {
             return (int)_vehicle.Type;   // if we are a vehicle, return that type
-        }
+        } 
         set {
             Vehicle type = (Vehicle)value;
-
-            // Tell the scene about the vehicle so it will get processing each frame.
-            PhysicsScene.VehicleInSceneTypeChanged(this, type);
-
-            PhysicsScene.TaintedObject("setVehicleType", delegate()
+            BSPrim vehiclePrim = this;
+            _scene.TaintedObject("setVehicleType", delegate()
             {
                 // Done at taint time so we're sure the physics engine is not using the variables
                 // Vehicle code changes the parameters for this vehicle type.
                 _vehicle.ProcessTypeChange(type);
-                ActivateIfPhysical(false);
+                // Tell the scene about the vehicle so it will get processing each frame.
+                _scene.VehicleInSceneTypeChanged(this, type);
             });
-        }
+        } 
     }
-    public override void VehicleFloatParam(int param, float value)
+    public override void VehicleFloatParam(int param, float value) 
     {
-        PhysicsScene.TaintedObject("BSPrim.VehicleFloatParam", delegate()
+        _scene.TaintedObject("BSPrim.VehicleFloatParam", delegate()
         {
-            _vehicle.ProcessFloatVehicleParam((Vehicle)param, value);
-            ActivateIfPhysical(false);
+            _vehicle.ProcessFloatVehicleParam((Vehicle)param, value, _scene.LastSimulatedTimestep);
         });
     }
-    public override void VehicleVectorParam(int param, OMV.Vector3 value)
+    public override void VehicleVectorParam(int param, OMV.Vector3 value) 
     {
-        PhysicsScene.TaintedObject("BSPrim.VehicleVectorParam", delegate()
+        _scene.TaintedObject("BSPrim.VehicleVectorParam", delegate()
         {
-            _vehicle.ProcessVectorVehicleParam((Vehicle)param, value);
-            ActivateIfPhysical(false);
+            _vehicle.ProcessVectorVehicleParam((Vehicle)param, value, _scene.LastSimulatedTimestep);
         });
     }
-    public override void VehicleRotationParam(int param, OMV.Quaternion rotation)
+    public override void VehicleRotationParam(int param, OMV.Quaternion rotation) 
     {
-        PhysicsScene.TaintedObject("BSPrim.VehicleRotationParam", delegate()
+        _scene.TaintedObject("BSPrim.VehicleRotationParam", delegate()
         {
             _vehicle.ProcessRotationVehicleParam((Vehicle)param, rotation);
-            ActivateIfPhysical(false);
         });
     }
-    public override void VehicleFlags(int param, bool remove)
+    public override void VehicleFlags(int param, bool remove) 
     {
-        PhysicsScene.TaintedObject("BSPrim.VehicleFlags", delegate()
+        _scene.TaintedObject("BSPrim.VehicleFlags", delegate()
         {
             _vehicle.ProcessVehicleFlags(param, remove);
         });
@@ -462,355 +391,143 @@ public sealed class BSPrim : BSPhysObject
 
     // Called each simulation step to advance vehicle characteristics.
     // Called from Scene when doing simulation step so we're in taint processing time.
-    public override void StepVehicle(float timeStep)
+    public void StepVehicle(float timeStep)
     {
-        if (IsPhysical && _vehicle.IsActive)
-        {
+        if (IsPhysical)
             _vehicle.Step(timeStep);
-            /* // TEST TEST DEBUG DEBUG -- trying to reduce the extra action of Bullet simulation step
-            PhysicsScene.PostTaintObject("BSPrim.StepVehicles", LocalID, delegate()
-            {
-                // This resets the interpolation values and recomputes the tensor variables
-                BulletSimAPI.SetCenterOfMassByPosRot2(BSBody.ptr, ForcePosition, ForceOrientation);
-            });
-             */
-        }
     }
 
     // Allows the detection of collisions with inherently non-physical prims. see llVolumeDetect for more
     public override void SetVolumeDetect(int param) {
         bool newValue = (param != 0);
-        if (_isVolumeDetect != newValue)
+        _isVolumeDetect = newValue;
+        _scene.TaintedObject("BSPrim.SetVolumeDetect", delegate()
         {
-            _isVolumeDetect = newValue;
-            PhysicsScene.TaintedObject("BSPrim.SetVolumeDetect", delegate()
-            {
-                // DetailLog("{0},setVolumeDetect,taint,volDetect={1}", LocalID, _isVolumeDetect);
-                SetObjectDynamic(true);
-            });
-        }
-        return;
+            SetObjectDynamic();
+        });
+        return; 
     }
-    public override OMV.Vector3 Velocity {
-        get { return _velocity; }
+
+    public override OMV.Vector3 Velocity { 
+        get { return _velocity; } 
         set {
             _velocity = value;
-            PhysicsScene.TaintedObject("BSPrim.setVelocity", delegate()
+            _scene.TaintedObject("BSPrim.setVelocity", delegate()
             {
                 // DetailLog("{0},BSPrim.SetVelocity,taint,vel={1}", LocalID, _velocity);
-                BulletSimAPI.SetLinearVelocity2(PhysBody.ptr, _velocity);
+                BulletSimAPI.SetObjectVelocity(_scene.WorldID, LocalID, _velocity);
             });
-        }
-    }
-    public override OMV.Vector3 ForceVelocity {
-        get { return _velocity; }
-        set {
-            _velocity = value;
-            BulletSimAPI.SetLinearVelocity2(PhysBody.ptr, _velocity);
-        }
+        } 
     }
-    public override OMV.Vector3 Torque {
-        get { return _torque; }
-        set {
-            _torque = value;
-            AddAngularForce(_torque, false, false);
+    public override OMV.Vector3 Torque { 
+        get { return _torque; } 
+        set { _torque = value; 
             // DetailLog("{0},BSPrim.SetTorque,call,torque={1}", LocalID, _torque);
-        }
+        } 
     }
-    public override float CollisionScore {
-        get { return _collisionScore; }
-        set { _collisionScore = value;
-        }
+    public override float CollisionScore { 
+        get { return _collisionScore; } 
+        set { _collisionScore = value; 
+        } 
     }
-    public override OMV.Vector3 Acceleration {
+    public override OMV.Vector3 Acceleration { 
         get { return _acceleration; }
         set { _acceleration = value; }
     }
-    public override OMV.Quaternion RawOrientation
-    {
-        get { return _orientation; }
-        set { _orientation = value; }
-    }
-    public override OMV.Quaternion Orientation {
+    public override OMV.Quaternion Orientation { 
         get {
-            // Children move around because tied to parent. Get a fresh value.
-            if (!Linkset.IsRoot(this))
+            if (!_linkset.IsRoot(this))
             {
-                _orientation = Linkset.Orientation(this);
+                // Children move around because tied to parent. Get a fresh value.
+                _orientation = BulletSimAPI.GetObjectOrientation(_scene.WorldID, LocalID);
             }
             return _orientation;
-        }
+        } 
         set {
-            if (_orientation == value)
-                return;
             _orientation = value;
             // TODO: what does it mean if a child in a linkset changes its orientation? Rebuild the constraint?
-            PhysicsScene.TaintedObject("BSPrim.setOrientation", delegate()
+            _scene.TaintedObject("BSPrim.setOrientation", delegate()
             {
-                // _position = BulletSimAPI.GetObjectPosition2(PhysicsScene.World.ptr, BSBody.ptr);
+                // _position = BulletSimAPI.GetObjectPosition(_scene.WorldID, _localID);
                 // DetailLog("{0},BSPrim.setOrientation,taint,pos={1},orient={2}", LocalID, _position, _orientation);
-                BulletSimAPI.SetTranslation2(PhysBody.ptr, _position, _orientation);
+                BulletSimAPI.SetObjectTranslation(_scene.WorldID, _localID, _position, _orientation);
             });
-        }
+        } 
     }
-    // Go directly to Bullet to get/set the value.
-    public override OMV.Quaternion ForceOrientation
-    {
-        get
-        {
-            _orientation = BulletSimAPI.GetOrientation2(PhysBody.ptr);
-            return _orientation;
-        }
-        set
-        {
-            _orientation = value;
-            BulletSimAPI.SetTranslation2(PhysBody.ptr, _position, _orientation);
-        }
+    public override int PhysicsActorType { 
+        get { return _physicsActorType; } 
+        set { _physicsActorType = value; 
+        } 
     }
-    public override int PhysicsActorType {
-        get { return _physicsActorType; }
-        set { _physicsActorType = value; }
-    }
-    public override bool IsPhysical {
-        get { return _isPhysical; }
+    public override bool IsPhysical { 
+        get { return _isPhysical; } 
         set {
-            if (_isPhysical != value)
+            _isPhysical = value;
+            _scene.TaintedObject("BSPrim.setIsPhysical", delegate()
             {
-                _isPhysical = value;
-                PhysicsScene.TaintedObject("BSPrim.setIsPhysical", delegate()
-                {
-                    // DetailLog("{0},setIsPhysical,taint,isPhys={1}", LocalID, _isPhysical);
-                    SetObjectDynamic(true);
-                    // whether phys-to-static or static-to-phys, the object is not moving.
-                    ZeroMotion();
-                });
-            }
-        }
+                SetObjectDynamic();
+            });
+        } 
     }
 
     // An object is static (does not move) if selected or not physical
-    public override bool IsStatic
+    private bool IsStatic
     {
         get { return _isSelected || !IsPhysical; }
     }
 
     // An object is solid if it's not phantom and if it's not doing VolumeDetect
-    public override bool IsSolid
+    private bool IsSolid
     {
         get { return !IsPhantom && !_isVolumeDetect; }
     }
 
     // Make gravity work if the object is physical and not selected
-    // Called at taint-time!!
-    private void SetObjectDynamic(bool forceRebuild)
-    {
-        // Recreate the physical object if necessary
-        CreateGeomAndObject(forceRebuild);
-    }
-
-    // Convert the simulator's physical properties into settings on BulletSim objects.
-    // There are four flags we're interested in:
-    //     IsStatic: Object does not move, otherwise the object has mass and moves
-    //     isSolid: other objects bounce off of this object
-    //     isVolumeDetect: other objects pass through but can generate collisions
-    //     collisionEvents: whether this object returns collision events
-    private void UpdatePhysicalParameters()
-    {
-        // DetailLog("{0},BSPrim.UpdatePhysicalParameters,entry,body={1},shape={2}", LocalID, BSBody, BSShape);
-
-        // Mangling all the physical properties requires the object not be in the physical world.
-        // This is a NOOP if the object is not in the world (BulletSim and Bullet ignore objects not found).
-        BulletSimAPI.RemoveObjectFromWorld2(PhysicsScene.World.ptr, PhysBody.ptr);
-
-        // Set up the object physicalness (does gravity and collisions move this object)
-        MakeDynamic(IsStatic);
-
-        // Update vehicle specific parameters (after MakeDynamic() so can change physical parameters)
-        _vehicle.Refresh();
-
-        // Arrange for collision events if the simulator wants them
-        EnableCollisions(SubscribedEvents());
-
-        // Make solid or not (do things bounce off or pass through this object).
-        MakeSolid(IsSolid);
-
-        BulletSimAPI.AddObjectToWorld2(PhysicsScene.World.ptr, PhysBody.ptr);
-
-        // Rebuild its shape
-        BulletSimAPI.UpdateSingleAabb2(PhysicsScene.World.ptr, PhysBody.ptr);
-
-        // Collision filter can be set only when the object is in the world
-        if (PhysBody.collisionFilter != 0 || PhysBody.collisionMask != 0)
-        {
-            BulletSimAPI.SetCollisionFilterMask2(PhysBody.ptr, (uint)PhysBody.collisionFilter, (uint)PhysBody.collisionMask);
-        }
-
-        // Recompute any linkset parameters.
-        // When going from non-physical to physical, this re-enables the constraints that
-        //     had been automatically disabled when the mass was set to zero.
-        Linkset.Refresh(this);
-
-        DetailLog("{0},BSPrim.UpdatePhysicalParameters,taintExit,static={1},solid={2},mass={3},collide={4},cf={5:X},body={6},shape={7}",
-                        LocalID, IsStatic, IsSolid, _mass, SubscribedEvents(), CurrentCollisionFlags, PhysBody, PhysShape);
-    }
-
-    // "Making dynamic" means changing to and from static.
-    // When static, gravity does not effect the object and it is fixed in space.
-    // When dynamic, the object can fall and be pushed by others.
-    // This is independent of its 'solidness' which controls what passes through
-    //    this object and what interacts with it.
-    private void MakeDynamic(bool makeStatic)
+    // No locking here because only called when it is safe
+    private void SetObjectDynamic()
     {
-        if (makeStatic)
-        {
-            // Become a Bullet 'static' object type
-            CurrentCollisionFlags = BulletSimAPI.AddToCollisionFlags2(PhysBody.ptr, CollisionFlags.CF_STATIC_OBJECT);
-            // Stop all movement
-            ZeroMotion();
-            // Center of mass is at the center of the object
-            BulletSimAPI.SetCenterOfMassByPosRot2(Linkset.LinksetRoot.PhysBody.ptr, _position, _orientation);
-            // Mass is zero which disables a bunch of physics stuff in Bullet
-            UpdatePhysicalMassProperties(0f);
-            // Set collision detection parameters
-            if (PhysicsScene.Params.ccdMotionThreshold > 0f)
-            {
-                BulletSimAPI.SetCcdMotionThreshold2(PhysBody.ptr, PhysicsScene.Params.ccdMotionThreshold);
-                BulletSimAPI.SetCcdSweptSphereRadius2(PhysBody.ptr, PhysicsScene.Params.ccdSweptSphereRadius);
-            }
-            // There can be special things needed for implementing linksets
-            Linkset.MakeStatic(this);
-            // The activation state is 'disabled' so Bullet will not try to act on it.
-            BulletSimAPI.ForceActivationState2(PhysBody.ptr, ActivationState.DISABLE_SIMULATION);
-            // Start it out sleeping and physical actions could wake it up.
-            // BulletSimAPI.ForceActivationState2(BSBody.ptr, ActivationState.ISLAND_SLEEPING);
-
-            PhysBody.collisionFilter = CollisionFilterGroups.StaticObjectFilter;
-            PhysBody.collisionMask = CollisionFilterGroups.StaticObjectMask;
-        }
-        else
-        {
-            // Not a Bullet static object
-            CurrentCollisionFlags = BulletSimAPI.RemoveFromCollisionFlags2(PhysBody.ptr, CollisionFlags.CF_STATIC_OBJECT);
-
-            // Set various physical properties so internal dynamic properties will get computed correctly as they are set
-            BulletSimAPI.SetFriction2(PhysBody.ptr, PhysicsScene.Params.defaultFriction);
-            BulletSimAPI.SetRestitution2(PhysBody.ptr, PhysicsScene.Params.defaultRestitution);
-
-            // per http://www.bulletphysics.org/Bullet/phpBB3/viewtopic.php?t=3382
-            // Since this can be called multiple times, only zero forces when becoming physical
-            // BulletSimAPI.ClearAllForces2(BSBody.ptr);
+        // RA: remove this for the moment.
+        // The problem is that dynamic objects are hulls so if we are becoming physical
+        //    the shape has to be checked and possibly built.
+        //    Maybe a VerifyCorrectPhysicalShape() routine?
+        // RecreateGeomAndObject();
 
-            // For good measure, make sure the transform is set through to the motion state
-            BulletSimAPI.SetTranslation2(PhysBody.ptr, _position, _orientation);
+        // Bullet wants static objects to have a mass of zero
+        float mass = IsStatic ? 0f : _mass;
 
-            // Center of mass is at the center of the object
-            BulletSimAPI.SetCenterOfMassByPosRot2(Linkset.LinksetRoot.PhysBody.ptr, _position, _orientation);
-
-            // A dynamic object has mass
-            UpdatePhysicalMassProperties(RawMass);
-
-            // Set collision detection parameters
-            if (PhysicsScene.Params.ccdMotionThreshold > 0f)
-            {
-                BulletSimAPI.SetCcdMotionThreshold2(PhysBody.ptr, PhysicsScene.Params.ccdMotionThreshold);
-                BulletSimAPI.SetCcdSweptSphereRadius2(PhysBody.ptr, PhysicsScene.Params.ccdSweptSphereRadius);
-            }
-
-            // Various values for simulation limits
-            BulletSimAPI.SetDamping2(PhysBody.ptr, PhysicsScene.Params.linearDamping, PhysicsScene.Params.angularDamping);
-            BulletSimAPI.SetDeactivationTime2(PhysBody.ptr, PhysicsScene.Params.deactivationTime);
-            BulletSimAPI.SetSleepingThresholds2(PhysBody.ptr, PhysicsScene.Params.linearSleepingThreshold, PhysicsScene.Params.angularSleepingThreshold);
-            BulletSimAPI.SetContactProcessingThreshold2(PhysBody.ptr, PhysicsScene.Params.contactProcessingThreshold);
-
-            // There might be special things needed for implementing linksets.
-            Linkset.MakeDynamic(this);
-
-            // Force activation of the object so Bullet will act on it.
-            // Must do the ForceActivationState2() to overcome the DISABLE_SIMULATION from static objects.
-            BulletSimAPI.ForceActivationState2(PhysBody.ptr, ActivationState.ACTIVE_TAG);
-            // BulletSimAPI.Activate2(BSBody.ptr, true);
-
-            PhysBody.collisionFilter = CollisionFilterGroups.ObjectFilter;
-            PhysBody.collisionMask = CollisionFilterGroups.ObjectMask;
-        }
-    }
-
-    // "Making solid" means that other object will not pass through this object.
-    // To make transparent, we create a Bullet ghost object.
-    // Note: This expects to be called from the UpdatePhysicalParameters() routine as
-    //     the functions after this one set up the state of a possibly newly created collision body.
-    private void MakeSolid(bool makeSolid)
-    {
-        CollisionObjectTypes bodyType = (CollisionObjectTypes)BulletSimAPI.GetBodyType2(PhysBody.ptr);
-        if (makeSolid)
-        {
-            // Verify the previous code created the correct shape for this type of thing.
-            if ((bodyType & CollisionObjectTypes.CO_RIGID_BODY) == 0)
-            {
-                m_log.ErrorFormat("{0} MakeSolid: physical body of wrong type for solidity. id={1}, type={2}", LogHeader, LocalID, bodyType);
-            }
-            CurrentCollisionFlags = BulletSimAPI.RemoveFromCollisionFlags2(PhysBody.ptr, CollisionFlags.CF_NO_CONTACT_RESPONSE);
-        }
-        else
-        {
-            if ((bodyType & CollisionObjectTypes.CO_GHOST_OBJECT) == 0)
-            {
-                m_log.ErrorFormat("{0} MakeSolid: physical body of wrong type for non-solidness. id={1}, type={2}", LogHeader, LocalID, bodyType);
-            }
-            CurrentCollisionFlags = BulletSimAPI.AddToCollisionFlags2(PhysBody.ptr, CollisionFlags.CF_NO_CONTACT_RESPONSE);
-            PhysBody.collisionFilter = CollisionFilterGroups.VolumeDetectFilter;
-            PhysBody.collisionMask = CollisionFilterGroups.VolumeDetectMask;
-        }
-    }
+        BulletSimAPI.SetObjectProperties(_scene.WorldID, LocalID, IsStatic, IsSolid, SubscribedEvents(), mass);
 
-    // Enable physical actions. Bullet will keep sleeping non-moving physical objects so
-    //     they need waking up when parameters are changed.
-    // Called in taint-time!!
-    private void ActivateIfPhysical(bool forceIt)
-    {
-        if (IsPhysical)
-            BulletSimAPI.Activate2(PhysBody.ptr, forceIt);
-    }
+        // recompute any linkset parameters
+        _linkset.Refresh(this);
 
-    // Turn on or off the flag controlling whether collision events are returned to the simulator.
-    private void EnableCollisions(bool wantsCollisionEvents)
-    {
-        if (wantsCollisionEvents)
-        {
-            CurrentCollisionFlags = BulletSimAPI.AddToCollisionFlags2(PhysBody.ptr, CollisionFlags.BS_SUBSCRIBE_COLLISION_EVENTS);
-        }
-        else
-        {
-            CurrentCollisionFlags = BulletSimAPI.RemoveFromCollisionFlags2(PhysBody.ptr, CollisionFlags.BS_SUBSCRIBE_COLLISION_EVENTS);
-        }
+        CollisionFlags cf = BulletSimAPI.GetCollisionFlags2(Body.Ptr);
+        // DetailLog("{0},BSPrim.SetObjectDynamic,taint,static={1},solid={2},mass={3}, cf={4}", LocalID, IsStatic, IsSolid, mass, cf);
     }
 
     // prims don't fly
-    public override bool Flying {
-        get { return _flying; }
-        set {
-            _flying = value;
-        }
+    public override bool Flying { 
+        get { return _flying; } 
+        set { _flying = value; } 
     }
-    public override bool SetAlwaysRun {
-        get { return _setAlwaysRun; }
-        set { _setAlwaysRun = value; }
+    public override bool SetAlwaysRun { 
+        get { return _setAlwaysRun; } 
+        set { _setAlwaysRun = value; } 
     }
-    public override bool ThrottleUpdates {
-        get { return _throttleUpdates; }
-        set { _throttleUpdates = value; }
+    public override bool ThrottleUpdates { 
+        get { return _throttleUpdates; } 
+        set { _throttleUpdates = value; } 
     }
     public override bool IsColliding {
-        get { return (CollidingStep == PhysicsScene.SimulationStep); }
-        set { _isColliding = value; }
+        get { return (_collidingStep == _scene.SimulationStep); } 
+        set { _isColliding = value; } 
     }
     public override bool CollidingGround {
-        get { return (CollidingGroundStep == PhysicsScene.SimulationStep); }
-        set { _collidingGround = value; }
+        get { return (_collidingGroundStep == _scene.SimulationStep); } 
+        set { _collidingGround = value; } 
     }
-    public override bool CollidingObj {
-        get { return _collidingObj; }
-        set { _collidingObj = value; }
+    public override bool CollidingObj { 
+        get { return _collidingObj; } 
+        set { _collidingObj = value; } 
     }
     public bool IsPhantom {
         get {
@@ -820,19 +537,10 @@ public sealed class BSPrim : BSPhysObject
             return false;
         }
     }
-    public override bool FloatOnWater {
-        set {
-            _floatOnWater = value;
-            PhysicsScene.TaintedObject("BSPrim.setFloatOnWater", delegate()
-            {
-                if (_floatOnWater)
-                    CurrentCollisionFlags = BulletSimAPI.AddToCollisionFlags2(PhysBody.ptr, CollisionFlags.BS_FLOATS_ON_WATER);
-                else
-                    CurrentCollisionFlags = BulletSimAPI.RemoveFromCollisionFlags2(PhysBody.ptr, CollisionFlags.BS_FLOATS_ON_WATER);
-            });
-        }
+    public override bool FloatOnWater { 
+        set { _floatOnWater = value; } 
     }
-    public override OMV.Vector3 RotationalVelocity {
+    public override OMV.Vector3 RotationalVelocity { 
         get {
             /*
             OMV.Vector3 pv = OMV.Vector3.Zero;
@@ -844,76 +552,58 @@ public sealed class BSPrim : BSPhysObject
              */
 
             return _rotationalVelocity;
-        }
+        } 
         set {
             _rotationalVelocity = value;
             // m_log.DebugFormat("{0}: RotationalVelocity={1}", LogHeader, _rotationalVelocity);
-            PhysicsScene.TaintedObject("BSPrim.setRotationalVelocity", delegate()
+            _scene.TaintedObject("BSPrim.setRotationalVelocity", delegate()
             {
-                DetailLog("{0},BSPrim.SetRotationalVel,taint,rotvel={1}", LocalID, _rotationalVelocity);
-                BulletSimAPI.SetAngularVelocity2(PhysBody.ptr, _rotationalVelocity);
+                // DetailLog("{0},BSPrim.SetRotationalVel,taint,rotvel={1}", LocalID, _rotationalVelocity);
+                BulletSimAPI.SetObjectAngularVelocity(_scene.WorldID, LocalID, _rotationalVelocity);
             });
-        }
-    }
-    public override OMV.Vector3 ForceRotationalVelocity {
-        get {
-            return _rotationalVelocity;
-        }
-        set {
-            _rotationalVelocity = value;
-            BulletSimAPI.SetAngularVelocity2(PhysBody.ptr, _rotationalVelocity);
-        }
+        } 
     }
-    public override bool Kinematic {
-        get { return _kinematic; }
-        set { _kinematic = value;
+    public override bool Kinematic { 
+        get { return _kinematic; } 
+        set { _kinematic = value; 
             // m_log.DebugFormat("{0}: Kinematic={1}", LogHeader, _kinematic);
-        }
+        } 
     }
-    public override float Buoyancy {
-        get { return _buoyancy; }
+    public override float Buoyancy { 
+        get { return _buoyancy; } 
         set {
             _buoyancy = value;
-            PhysicsScene.TaintedObject("BSPrim.setBuoyancy", delegate()
+            _scene.TaintedObject("BSPrim.setBuoyancy", delegate()
             {
-                ForceBuoyancy = _buoyancy;
+                // DetailLog("{0},BSPrim.SetBuoyancy,taint,buoy={1}", LocalID, _buoyancy);
+                BulletSimAPI.SetObjectBuoyancy(_scene.WorldID, _localID, _buoyancy);
             });
-        }
-    }
-    public override float ForceBuoyancy {
-        get { return _buoyancy; }
-        set {
-            _buoyancy = value;
-            // DetailLog("{0},BSPrim.setForceBuoyancy,taint,buoy={1}", LocalID, _buoyancy);
-            // Buoyancy is faked by changing the gravity applied to the object
-            float grav = PhysicsScene.Params.gravity * (1f - _buoyancy);
-            BulletSimAPI.SetGravity2(PhysBody.ptr, new OMV.Vector3(0f, 0f, grav));
-        }
+        } 
     }
 
     // Used for MoveTo
-    public override OMV.Vector3 PIDTarget {
-        set { _PIDTarget = value; }
+    public override OMV.Vector3 PIDTarget { 
+        set { _PIDTarget = value; } 
     }
-    public override bool PIDActive {
-        set { _usePID = value; }
+    public override bool PIDActive { 
+        set { _usePID = value; } 
     }
-    public override float PIDTau {
-        set { _PIDTau = value; }
+    public override float PIDTau { 
+        set { _PIDTau = value; } 
     }
 
     // Used for llSetHoverHeight and maybe vehicle height
     // Hover Height will override MoveTo target's Z
-    public override bool PIDHoverActive {
+    public override bool PIDHoverActive { 
         set { _useHoverPID = value; }
     }
-    public override float PIDHoverHeight {
+    public override float PIDHoverHeight { 
         set { _PIDHoverHeight = value; }
     }
-    public override PIDHoverType PIDHoverType {
+    public override PIDHoverType PIDHoverType { 
         set { _PIDHoverType = value; }
     }
-    public override float PIDHoverTau {
+    public override float PIDHoverTau { 
         set { _PIDHoverTao = value; }
     }
 
@@ -925,9 +615,6 @@ public sealed class BSPrim : BSPhysObject
 
     private List<OMV.Vector3> m_accumulatedForces = new List<OMV.Vector3>();
     public override void AddForce(OMV.Vector3 force, bool pushforce) {
-        AddForce(force, pushforce, false);
-    }
-    public void AddForce(OMV.Vector3 force, bool pushforce, bool inTaintTime) {
         // for an object, doesn't matter if force is a pushforce or not
         if (force.IsFinite())
         {
@@ -937,78 +624,56 @@ public sealed class BSPrim : BSPhysObject
         }
         else
         {
-            m_log.WarnFormat("{0}: Got a NaN force applied to a prim. LocalID={1}", LogHeader, LocalID);
+            m_log.WarnFormat("{0}: Got a NaN force applied to a Character", LogHeader);
             return;
         }
-        PhysicsScene.TaintedObject(inTaintTime, "BSPrim.AddForce", delegate()
+        _scene.TaintedObject("BSPrim.AddForce", delegate()
         {
             OMV.Vector3 fSum = OMV.Vector3.Zero;
             lock (m_accumulatedForces)
             {
-                // Sum the accumulated additional forces for one big force to apply once.
                 foreach (OMV.Vector3 v in m_accumulatedForces)
                 {
                     fSum += v;
                 }
                 m_accumulatedForces.Clear();
             }
-            DetailLog("{0},BSPrim.AddForce,taint,force={1}", LocalID, fSum);
-            if (fSum != OMV.Vector3.Zero)
-                BulletSimAPI.ApplyCentralForce2(PhysBody.ptr, fSum);
+            // DetailLog("{0},BSPrim.AddObjectForce,taint,force={1}", LocalID, _force);
+            BulletSimAPI.AddObjectForce2(Body.Ptr, fSum);
         });
     }
 
-    private List<OMV.Vector3> m_accumulatedAngularForces = new List<OMV.Vector3>();
-    public override void AddAngularForce(OMV.Vector3 force, bool pushforce) {
-        AddAngularForce(force, pushforce, false);
+    public override void AddAngularForce(OMV.Vector3 force, bool pushforce) { 
+        // DetailLog("{0},BSPrim.AddAngularForce,call,angForce={1},push={2}", LocalID, force, pushforce);
+        // m_log.DebugFormat("{0}: AddAngularForce. f={1}, push={2}", LogHeader, force, pushforce);
     }
-    public void AddAngularForce(OMV.Vector3 force, bool pushforce, bool inTaintTime)
-    {
-        if (force.IsFinite())
-        {
-            // _force += force;
-            lock (m_accumulatedAngularForces)
-                m_accumulatedAngularForces.Add(new OMV.Vector3(force));
-        }
-        else
-        {
-            m_log.WarnFormat("{0}: Got a NaN force applied to a prim. LocalID={1}", LogHeader, LocalID);
-            return;
-        }
-        PhysicsScene.TaintedObject(inTaintTime, "BSPrim.AddAngularForce", delegate()
+    public override void SetMomentum(OMV.Vector3 momentum) { 
+        // DetailLog("{0},BSPrim.SetMomentum,call,mom={1}", LocalID, momentum);
+    }
+    public override void SubscribeEvents(int ms) { 
+        _subscribedEventsMs = ms;
+        if (ms > 0)
         {
-            OMV.Vector3 fSum = OMV.Vector3.Zero;
-            lock (m_accumulatedAngularForces)
-            {
-                // Sum the accumulated additional forces for one big force to apply once.
-                foreach (OMV.Vector3 v in m_accumulatedAngularForces)
-                {
-                    fSum += v;
-                }
-                m_accumulatedAngularForces.Clear();
-            }
-            DetailLog("{0},BSPrim.AddAngularForce,taint,aForce={1}", LocalID, fSum);
-            if (fSum != OMV.Vector3.Zero)
+            // make sure first collision happens
+            _nextCollisionOkTime = Util.EnvironmentTickCount() - _subscribedEventsMs;
+
+            Scene.TaintedObject("BSPrim.SubscribeEvents", delegate()
             {
-                BulletSimAPI.ApplyTorque2(PhysBody.ptr, fSum);
-                _torque = fSum;
-            }
-        });
+                BulletSimAPI.AddToCollisionFlags2(Body.Ptr, CollisionFlags.BS_SUBSCRIBE_COLLISION_EVENTS);
+            });
+        }
     }
-    // A torque impulse.
-    public void ApplyTorqueImpulse(OMV.Vector3 impulse, bool inTaintTime)
-    {
-        OMV.Vector3 applyImpulse = impulse;
-        PhysicsScene.TaintedObject(inTaintTime, "BSPrim.ApplyTorqueImpulse", delegate()
+    public override void UnSubscribeEvents() { 
+        _subscribedEventsMs = 0;
+        Scene.TaintedObject("BSPrim.UnSubscribeEvents", delegate()
         {
-            DetailLog("{0},BSPrim.ApplyTorqueImpulse,taint,tImpulse={1}", LocalID, applyImpulse);
-            BulletSimAPI.ApplyTorqueImpulse2(PhysBody.ptr, applyImpulse);
+            BulletSimAPI.RemoveFromCollisionFlags2(Body.Ptr, CollisionFlags.BS_SUBSCRIBE_COLLISION_EVENTS);
         });
     }
-
-    public override void SetMomentum(OMV.Vector3 momentum) {
-        // DetailLog("{0},BSPrim.SetMomentum,call,mom={1}", LocalID, momentum);
+    public override bool SubscribedEvents() { 
+        return (_subscribedEventsMs > 0);
     }
+
     #region Mass Calculation
 
     private float CalculateMass()
@@ -1017,19 +682,19 @@ public sealed class BSPrim : BSPhysObject
         float tmp;
 
         float returnMass = 0;
-        float hollowAmount = (float)BaseShape.ProfileHollow * 2.0e-5f;
-        float hollowVolume = hollowAmount * hollowAmount;
-
-        switch (BaseShape.ProfileShape)
+        float hollowAmount = (float)_pbs.ProfileHollow * 2.0e-5f;
+        float hollowVolume = hollowAmount * hollowAmount; 
+        
+        switch (_pbs.ProfileShape)
         {
             case ProfileShape.Square:
                 // default box
 
-                if (BaseShape.PathCurve == (byte)Extrusion.Straight)
+                if (_pbs.PathCurve == (byte)Extrusion.Straight)
                     {
                     if (hollowAmount > 0.0)
                         {
-                        switch (BaseShape.HollowShape)
+                        switch (_pbs.HollowShape)
                             {
                             case HollowShape.Square:
                             case HollowShape.Same:
@@ -1053,19 +718,19 @@ public sealed class BSPrim : BSPhysObject
                         }
                     }
 
-                else if (BaseShape.PathCurve == (byte)Extrusion.Curve1)
+                else if (_pbs.PathCurve == (byte)Extrusion.Curve1)
                     {
-                    //a tube
+                    //a tube 
 
-                    volume *= 0.78539816339e-2f * (float)(200 - BaseShape.PathScaleX);
-                    tmp= 1.0f -2.0e-2f * (float)(200 - BaseShape.PathScaleY);
+                    volume *= 0.78539816339e-2f * (float)(200 - _pbs.PathScaleX);
+                    tmp= 1.0f -2.0e-2f * (float)(200 - _pbs.PathScaleY);
                     volume -= volume*tmp*tmp;
-
+                    
                     if (hollowAmount > 0.0)
                         {
                         hollowVolume *= hollowAmount;
-
-                        switch (BaseShape.HollowShape)
+                        
+                        switch (_pbs.HollowShape)
                             {
                             case HollowShape.Square:
                             case HollowShape.Same:
@@ -1090,13 +755,13 @@ public sealed class BSPrim : BSPhysObject
 
             case ProfileShape.Circle:
 
-                if (BaseShape.PathCurve == (byte)Extrusion.Straight)
+                if (_pbs.PathCurve == (byte)Extrusion.Straight)
                     {
                     volume *= 0.78539816339f; // elipse base
 
                     if (hollowAmount > 0.0)
                         {
-                        switch (BaseShape.HollowShape)
+                        switch (_pbs.HollowShape)
                             {
                             case HollowShape.Same:
                             case HollowShape.Circle:
@@ -1118,19 +783,19 @@ public sealed class BSPrim : BSPhysObject
                         }
                     }
 
-                else if (BaseShape.PathCurve == (byte)Extrusion.Curve1)
+                else if (_pbs.PathCurve == (byte)Extrusion.Curve1)
                     {
-                    volume *= 0.61685027506808491367715568749226e-2f * (float)(200 - BaseShape.PathScaleX);
-                    tmp = 1.0f - .02f * (float)(200 - BaseShape.PathScaleY);
+                    volume *= 0.61685027506808491367715568749226e-2f * (float)(200 - _pbs.PathScaleX);
+                    tmp = 1.0f - .02f * (float)(200 - _pbs.PathScaleY);
                     volume *= (1.0f - tmp * tmp);
-
+                    
                     if (hollowAmount > 0.0)
                         {
 
                         // calculate the hollow volume by it's shape compared to the prim shape
                         hollowVolume *= hollowAmount;
 
-                        switch (BaseShape.HollowShape)
+                        switch (_pbs.HollowShape)
                             {
                             case HollowShape.Same:
                             case HollowShape.Circle:
@@ -1154,7 +819,7 @@ public sealed class BSPrim : BSPhysObject
                 break;
 
             case ProfileShape.HalfCircle:
-                if (BaseShape.PathCurve == (byte)Extrusion.Curve1)
+                if (_pbs.PathCurve == (byte)Extrusion.Curve1)
                 {
                 volume *= 0.52359877559829887307710723054658f;
                 }
@@ -1162,7 +827,7 @@ public sealed class BSPrim : BSPhysObject
 
             case ProfileShape.EquilateralTriangle:
 
-                if (BaseShape.PathCurve == (byte)Extrusion.Straight)
+                if (_pbs.PathCurve == (byte)Extrusion.Straight)
                     {
                     volume *= 0.32475953f;
 
@@ -1170,7 +835,7 @@ public sealed class BSPrim : BSPhysObject
                         {
 
                         // calculate the hollow volume by it's shape compared to the prim shape
-                        switch (BaseShape.HollowShape)
+                        switch (_pbs.HollowShape)
                             {
                             case HollowShape.Same:
                             case HollowShape.Triangle:
@@ -1195,11 +860,11 @@ public sealed class BSPrim : BSPhysObject
                         volume *= (1.0f - hollowVolume);
                         }
                     }
-                else if (BaseShape.PathCurve == (byte)Extrusion.Curve1)
+                else if (_pbs.PathCurve == (byte)Extrusion.Curve1)
                     {
                     volume *= 0.32475953f;
-                    volume *= 0.01f * (float)(200 - BaseShape.PathScaleX);
-                    tmp = 1.0f - .02f * (float)(200 - BaseShape.PathScaleY);
+                    volume *= 0.01f * (float)(200 - _pbs.PathScaleX);
+                    tmp = 1.0f - .02f * (float)(200 - _pbs.PathScaleY);
                     volume *= (1.0f - tmp * tmp);
 
                     if (hollowAmount > 0.0)
@@ -1207,7 +872,7 @@ public sealed class BSPrim : BSPhysObject
 
                         hollowVolume *= hollowAmount;
 
-                        switch (BaseShape.HollowShape)
+                        switch (_pbs.HollowShape)
                             {
                             case HollowShape.Same:
                             case HollowShape.Triangle:
@@ -1247,26 +912,26 @@ public sealed class BSPrim : BSPhysObject
         float profileBegin;
         float profileEnd;
 
-        if (BaseShape.PathCurve == (byte)Extrusion.Straight || BaseShape.PathCurve == (byte)Extrusion.Flexible)
+        if (_pbs.PathCurve == (byte)Extrusion.Straight || _pbs.PathCurve == (byte)Extrusion.Flexible)
             {
-            taperX1 = BaseShape.PathScaleX * 0.01f;
+            taperX1 = _pbs.PathScaleX * 0.01f;
             if (taperX1 > 1.0f)
                 taperX1 = 2.0f - taperX1;
             taperX = 1.0f - taperX1;
 
-            taperY1 = BaseShape.PathScaleY * 0.01f;
+            taperY1 = _pbs.PathScaleY * 0.01f;
             if (taperY1 > 1.0f)
                 taperY1 = 2.0f - taperY1;
             taperY = 1.0f - taperY1;
             }
         else
             {
-            taperX = BaseShape.PathTaperX * 0.01f;
+            taperX = _pbs.PathTaperX * 0.01f;
             if (taperX < 0.0f)
                 taperX = -taperX;
             taperX1 = 1.0f - taperX;
 
-            taperY = BaseShape.PathTaperY * 0.01f;
+            taperY = _pbs.PathTaperY * 0.01f;
             if (taperY < 0.0f)
                 taperY = -taperY;
             taperY1 = 1.0f - taperY;
@@ -1276,18 +941,20 @@ public sealed class BSPrim : BSPhysObject
 
         volume *= (taperX1 * taperY1 + 0.5f * (taperX1 * taperY + taperX * taperY1) + 0.3333333333f * taperX * taperY);
 
-        pathBegin = (float)BaseShape.PathBegin * 2.0e-5f;
-        pathEnd = 1.0f - (float)BaseShape.PathEnd * 2.0e-5f;
+        pathBegin = (float)_pbs.PathBegin * 2.0e-5f;
+        pathEnd = 1.0f - (float)_pbs.PathEnd * 2.0e-5f;
         volume *= (pathEnd - pathBegin);
 
         // this is crude aproximation
-        profileBegin = (float)BaseShape.ProfileBegin * 2.0e-5f;
-        profileEnd = 1.0f - (float)BaseShape.ProfileEnd * 2.0e-5f;
+        profileBegin = (float)_pbs.ProfileBegin * 2.0e-5f;
+        profileEnd = 1.0f - (float)_pbs.ProfileEnd * 2.0e-5f;
         volume *= (profileEnd - profileBegin);
 
         returnMass = _density * volume;
 
-        /* Comment out code that computes the mass of the linkset. That is done in the Linkset class.
+        /*
+         * This change means each object keeps its own mass and the Mass property
+         * will return the sum if we're part of a linkset.
         if (IsRootOfLinkset)
         {
             foreach (BSPrim prim in _childrenPrims)
@@ -1300,42 +967,296 @@ public sealed class BSPrim : BSPhysObject
         if (returnMass <= 0)
             returnMass = 0.0001f;
 
-        if (returnMass > PhysicsScene.MaximumObjectMass)
-            returnMass = PhysicsScene.MaximumObjectMass;
+        if (returnMass > _scene.MaximumObjectMass)
+            returnMass = _scene.MaximumObjectMass;
 
         return returnMass;
     }// end CalculateMass
     #endregion Mass Calculation
 
-    // Rebuild the geometry and object.
-    // This is called when the shape changes so we need to recreate the mesh/hull.
-    // Called at taint-time!!!
-    private void CreateGeomAndObject(bool forceRebuild)
+    // Create the geometry information in Bullet for later use
+    // The objects needs a hull if it's physical otherwise a mesh is enough
+    // No locking here because this is done when we know physics is not simulating
+    // if 'forceRebuild' is true, the geometry is rebuilt. Otherwise a previously built version is used
+    // Returns 'true' if the geometry was rebuilt
+    private bool CreateGeom(bool forceRebuild)
     {
-        // If this prim is part of a linkset, we must remove and restore the physical
-        //    links if the body is rebuilt.
-        bool needToRestoreLinkset = false;
-
-        // Create the correct physical representation for this type of object.
-        // Updates BSBody and BSShape with the new information.
-        // Ignore 'forceRebuild'. This routine makes the right choices and changes of necessary.
-        // Returns 'true' if either the body or the shape was changed.
-        PhysicsScene.Shapes.GetBodyAndShape(false, PhysicsScene.World, this, null, delegate(BulletBody dBody)
+        // the mesher thought this was too simple to mesh. Use a native Bullet collision shape.
+        bool ret = false;
+        if (!_scene.NeedsMeshing(_pbs))
         {
-            // Called if the current prim body is about to be destroyed.
-            // Remove all the physical dependencies on the old body.
-            // (Maybe someday make the changing of BSShape an event handled by BSLinkset.)
-            needToRestoreLinkset = Linkset.RemoveBodyDependencies(this);
-        });
+            if (_pbs.ProfileShape == ProfileShape.HalfCircle && _pbs.PathCurve == (byte)Extrusion.Curve1)
+            {
+                // if (_size.X == _size.Y && _size.Y == _size.Z && _size.X == _size.Z)
+                // {
+                    // m_log.DebugFormat("{0}: CreateGeom: Defaulting to sphere of size {1}", LogHeader, _size);
+                    if (forceRebuild || (_shapeType != ShapeData.PhysicsShapeType.SHAPE_SPHERE))
+                    {
+                        // DetailLog("{0},BSPrim.CreateGeom,sphere (force={1}", LocalID, forceRebuild);
+                        _shapeType = ShapeData.PhysicsShapeType.SHAPE_SPHERE;
+                        // Bullet native objects are scaled by the Bullet engine so pass the size in
+                        _scale = _size;
+                        // TODO: do we need to check for and destroy a mesh or hull that might have been left from before?
+                        ret = true;
+                    }
+                // }
+            }
+            else
+            {
+                // m_log.DebugFormat("{0}: CreateGeom: Defaulting to box. lid={1}, type={2}, size={3}", LogHeader, LocalID, _shapeType, _size);
+                if (forceRebuild || (_shapeType != ShapeData.PhysicsShapeType.SHAPE_BOX))
+                {
+                    // DetailLog("{0},BSPrim.CreateGeom,box (force={1})", LocalID, forceRebuild);
+                    _shapeType = ShapeData.PhysicsShapeType.SHAPE_BOX;
+                    _scale = _size;
+                    // TODO: do we need to check for and destroy a mesh or hull that might have been left from before?
+                    ret = true;
+                }
+            }
+        }
+        else
+        {
+            if (IsPhysical)
+            {
+                if (forceRebuild || _hullKey == 0)
+                {
+                    // physical objects require a hull for interaction.
+                    // This will create the mesh if it doesn't already exist
+                    CreateGeomHull();
+                    ret = true;
+                }
+            }
+            else
+            {
+                if (forceRebuild || _meshKey == 0)
+                {
+                    // Static (non-physical) objects only need a mesh for bumping into
+                    CreateGeomMesh();
+                    ret = true;
+                }
+            }
+        }
+        return ret;
+    }
+
+    // No locking here because this is done when we know physics is not simulating
+    private void CreateGeomMesh()
+    {
+        float lod = _pbs.SculptEntry ? _scene.SculptLOD : _scene.MeshLOD;
+        ulong newMeshKey = (ulong)_pbs.GetMeshKey(_size, lod);
+        // m_log.DebugFormat("{0}: CreateGeomMesh: lID={1}, oldKey={2}, newKey={3}", LogHeader, _localID, _meshKey, newMeshKey);
+
+        // if this new shape is the same as last time, don't recreate the mesh
+        if (_meshKey == newMeshKey) return;
+
+        // DetailLog("{0},BSPrim.CreateGeomMesh,create,key={1}", LocalID, newMeshKey);
+        // Since we're recreating new, get rid of any previously generated shape
+        if (_meshKey != 0)
+        {
+            // m_log.DebugFormat("{0}: CreateGeom: deleting old mesh. lID={1}, Key={2}", LogHeader, _localID, _meshKey);
+            // DetailLog("{0},BSPrim.CreateGeomMesh,deleteOld,key={1}", LocalID, _meshKey);
+            BulletSimAPI.DestroyMesh(_scene.WorldID, _meshKey);
+            _mesh = null;
+            _meshKey = 0;
+        }
+
+        _meshKey = newMeshKey;
+        // always pass false for physicalness as this creates some sort of bounding box which we don't need
+        _mesh = _scene.mesher.CreateMesh(_avName, _pbs, _size, lod, false);
+
+        int[] indices = _mesh.getIndexListAsInt();
+        List<OMV.Vector3> vertices = _mesh.getVertexList();
+
+        float[] verticesAsFloats = new float[vertices.Count * 3];
+        int vi = 0;
+        foreach (OMV.Vector3 vv in vertices)
+        {
+            verticesAsFloats[vi++] = vv.X;
+            verticesAsFloats[vi++] = vv.Y;
+            verticesAsFloats[vi++] = vv.Z;
+        }
+
+        // m_log.DebugFormat("{0}: CreateGeomMesh: calling CreateMesh. lid={1}, key={2}, indices={3}, vertices={4}", 
+        //                  LogHeader, _localID, _meshKey, indices.Length, vertices.Count);
+        BulletSimAPI.CreateMesh(_scene.WorldID, _meshKey, indices.GetLength(0), indices, 
+                                                        vertices.Count, verticesAsFloats);
+
+        _shapeType = ShapeData.PhysicsShapeType.SHAPE_MESH;
+        // meshes are already scaled by the meshmerizer
+        _scale = new OMV.Vector3(1f, 1f, 1f);
+        // DetailLog("{0},BSPrim.CreateGeomMesh,done", LocalID);
+        return;
+    }
+
+    // No locking here because this is done when we know physics is not simulating
+    private void CreateGeomHull()
+    {
+        float lod = _pbs.SculptEntry ? _scene.SculptLOD : _scene.MeshLOD;
+        ulong newHullKey = (ulong)_pbs.GetMeshKey(_size, lod);
+        // m_log.DebugFormat("{0}: CreateGeomHull: lID={1}, oldKey={2}, newKey={3}", LogHeader, _localID, _hullKey, newHullKey);
+
+        // if the hull hasn't changed, don't rebuild it
+        if (newHullKey == _hullKey) return;
 
-        if (needToRestoreLinkset)
+        // DetailLog("{0},BSPrim.CreateGeomHull,create,oldKey={1},newKey={2}", LocalID, _hullKey, newHullKey);
+        
+        // Since we're recreating new, get rid of any previously generated shape
+        if (_hullKey != 0)
         {
-            // If physical body dependencies were removed, restore them
-            Linkset.RestoreBodyDependencies(this);
+            // m_log.DebugFormat("{0}: CreateGeom: deleting old hull. Key={1}", LogHeader, _hullKey);
+            // DetailLog("{0},BSPrim.CreateGeomHull,deleteOldHull,key={1}", LocalID, _hullKey);
+            BulletSimAPI.DestroyHull(_scene.WorldID, _hullKey);
+            _hullKey = 0;
+        }
+
+        _hullKey = newHullKey;
+
+        // Make sure the underlying mesh exists and is correct
+        CreateGeomMesh();
+
+        int[] indices = _mesh.getIndexListAsInt();
+        List<OMV.Vector3> vertices = _mesh.getVertexList();
+
+        //format conversion from IMesh format to DecompDesc format
+        List<int> convIndices = new List<int>();
+        List<float3> convVertices = new List<float3>();
+        for (int ii = 0; ii < indices.GetLength(0); ii++)
+        {
+            convIndices.Add(indices[ii]);
+        }
+        foreach (OMV.Vector3 vv in vertices)
+        {
+            convVertices.Add(new float3(vv.X, vv.Y, vv.Z));
+        }
+
+        // setup and do convex hull conversion
+        _hulls = new List<ConvexResult>();
+        DecompDesc dcomp = new DecompDesc();
+        dcomp.mIndices = convIndices;
+        dcomp.mVertices = convVertices;
+        ConvexBuilder convexBuilder = new ConvexBuilder(HullReturn);
+        // create the hull into the _hulls variable
+        convexBuilder.process(dcomp);
+
+        // Convert the vertices and indices for passing to unmanaged.
+        // The hull information is passed as a large floating point array. 
+        // The format is:
+        //  convHulls[0] = number of hulls
+        //  convHulls[1] = number of vertices in first hull
+        //  convHulls[2] = hull centroid X coordinate
+        //  convHulls[3] = hull centroid Y coordinate
+        //  convHulls[4] = hull centroid Z coordinate
+        //  convHulls[5] = first hull vertex X
+        //  convHulls[6] = first hull vertex Y
+        //  convHulls[7] = first hull vertex Z
+        //  convHulls[8] = second hull vertex X
+        //  ...
+        //  convHulls[n] = number of vertices in second hull
+        //  convHulls[n+1] = second hull centroid X coordinate
+        //  ...
+        //
+        // TODO: is is very inefficient. Someday change the convex hull generator to return
+        //   data structures that do not need to be converted in order to pass to Bullet.
+        //   And maybe put the values directly into pinned memory rather than marshaling.
+        int hullCount = _hulls.Count;
+        int totalVertices = 1;          // include one for the count of the hulls
+        foreach (ConvexResult cr in _hulls)
+        {
+            totalVertices += 4;                         // add four for the vertex count and centroid
+            totalVertices += cr.HullIndices.Count * 3;  // we pass just triangles
+        }
+        float[] convHulls = new float[totalVertices];
+
+        convHulls[0] = (float)hullCount;
+        int jj = 1;
+        foreach (ConvexResult cr in _hulls)
+        {
+            // copy vertices for index access
+            float3[] verts = new float3[cr.HullVertices.Count];
+            int kk = 0;
+            foreach (float3 ff in cr.HullVertices)
+            {
+                verts[kk++] = ff;
+            }
+
+            // add to the array one hull's worth of data
+            convHulls[jj++] = cr.HullIndices.Count;
+            convHulls[jj++] = 0f;   // centroid x,y,z
+            convHulls[jj++] = 0f;
+            convHulls[jj++] = 0f;
+            foreach (int ind in cr.HullIndices)
+            {
+                convHulls[jj++] = verts[ind].x;
+                convHulls[jj++] = verts[ind].y;
+                convHulls[jj++] = verts[ind].z;
+            }
         }
 
-        // Make sure the properties are set on the new object
-        UpdatePhysicalParameters();
+        // create the hull definition in Bullet
+        // m_log.DebugFormat("{0}: CreateGeom: calling CreateHull. lid={1}, key={2}, hulls={3}", LogHeader, _localID, _hullKey, hullCount);
+        BulletSimAPI.CreateHull(_scene.WorldID, _hullKey, hullCount, convHulls);
+        _shapeType = ShapeData.PhysicsShapeType.SHAPE_HULL;
+        // meshes are already scaled by the meshmerizer
+        _scale = new OMV.Vector3(1f, 1f, 1f);
+        // DetailLog("{0},BSPrim.CreateGeomHull,done", LocalID);
+        return;
+    }
+
+    // Callback from convex hull creater with a newly created hull.
+    // Just add it to the collection of hulls for this shape.
+    private void HullReturn(ConvexResult result)
+    {
+        _hulls.Add(result);
+        return;
+    }
+
+    // Create an object in Bullet if it has not already been created
+    // No locking here because this is done when the physics engine is not simulating
+    // Returns 'true' if an object was actually created.
+    private bool CreateObject()
+    {
+        // this routine is called when objects are rebuilt. 
+
+        // the mesh or hull must have already been created in Bullet
+        ShapeData shape;
+        FillShapeInfo(out shape);
+        // m_log.DebugFormat("{0}: CreateObject: lID={1}, shape={2}", LogHeader, _localID, shape.Type);
+        bool ret = BulletSimAPI.CreateObject(_scene.WorldID, shape);
+
+        // the CreateObject() may have recreated the rigid body. Make sure we have the latest.
+        Body = new BulletBody(LocalID, BulletSimAPI.GetBodyHandle2(_scene.World.Ptr, LocalID));
+
+        return ret;
+    }
+
+    // Copy prim's info into the BulletSim shape description structure
+    public void FillShapeInfo(out ShapeData shape)
+    {
+        shape.ID = _localID;
+        shape.Type = _shapeType;
+        shape.Position = _position;
+        shape.Rotation = _orientation;
+        shape.Velocity = _velocity;
+        shape.Scale = _scale;
+        shape.Mass = _isPhysical ? _mass : 0f;
+        shape.Buoyancy = _buoyancy;
+        shape.HullKey = _hullKey;
+        shape.MeshKey = _meshKey;
+        shape.Friction = _friction;
+        shape.Restitution = _restitution;
+        shape.Collidable = (!IsPhantom) ? ShapeData.numericTrue : ShapeData.numericFalse;
+        shape.Static = _isPhysical ? ShapeData.numericFalse : ShapeData.numericTrue;
+    }
+
+
+    // Rebuild the geometry and object.
+    // This is called when the shape changes so we need to recreate the mesh/hull.
+    // No locking here because this is done when the physics engine is not simulating
+    private void RecreateGeomAndObject()
+    {
+        // m_log.DebugFormat("{0}: RecreateGeomAndObject. lID={1}", LogHeader, _localID);
+        if (CreateGeom(true))
+            CreateObject();
         return;
     }
 
@@ -1356,7 +1277,7 @@ public sealed class BSPrim : BSPhysObject
     const float ACCELERATION_TOLERANCE = 0.01f;
     const float ROTATIONAL_VELOCITY_TOLERANCE = 0.01f;
 
-    public override void UpdateProperties(EntityProperties entprop)
+    public void UpdateProperties(EntityProperties entprop)
     {
         /*
         UpdatedProperties changed = 0;
@@ -1404,7 +1325,7 @@ public sealed class BSPrim : BSPhysObject
         // Don't check for damping here -- it's done in BulletSim and SceneObjectPart.
 
         // Updates only for individual prims and for the root object of a linkset.
-        if (Linkset.IsRoot(this))
+        if (_linkset.IsRoot(this))
         {
             // Assign to the local variables so the normal set action does not happen
             _position = entprop.Position;
@@ -1413,32 +1334,69 @@ public sealed class BSPrim : BSPhysObject
             _acceleration = entprop.Acceleration;
             _rotationalVelocity = entprop.RotationalVelocity;
 
-            // remember the current and last set values
-            LastEntityProperties = CurrentEntityProperties;
-            CurrentEntityProperties = entprop;
-
-            PositionSanityCheck(true);
-
-            OMV.Vector3 direction = OMV.Vector3.UnitX * _orientation;
-            DetailLog("{0},BSPrim.UpdateProperties,call,pos={1},orient={2},dir={3},vel={4},rotVel={5}",
-                    LocalID, _position, _orientation, direction, _velocity, _rotationalVelocity);
-
-            // BulletSimAPI.DumpRigidBody2(PhysicsScene.World.ptr, BSBody.ptr);   // DEBUG DEBUG DEBUG
+            // m_log.DebugFormat("{0}: RequestTerseUpdate. id={1}, ch={2}, pos={3}, rot={4}, vel={5}, acc={6}, rvel={7}", 
+            //         LogHeader, LocalID, changed, _position, _orientation, _velocity, _acceleration, _rotationalVelocity);
+            // DetailLog("{0},BSPrim.UpdateProperties,call,pos={1},orient={2},vel={3},accel={4},rotVel={5}",
+            //         LocalID, _position, _orientation, _velocity, _acceleration, _rotationalVelocity);
 
             base.RequestPhysicsterseUpdate();
         }
             /*
         else
         {
-            // For debugging, report the movement of children
+            // For debugging, we also report the movement of children
             DetailLog("{0},BSPrim.UpdateProperties,child,pos={1},orient={2},vel={3},accel={4},rotVel={5}",
-                    LocalID, entprop.Position, entprop.Rotation, entprop.Velocity,
+                    LocalID, entprop.Position, entprop.Rotation, entprop.Velocity, 
                     entprop.Acceleration, entprop.RotationalVelocity);
         }
              */
+    }
+
+    // I've collided with something
+    CollisionEventUpdate collisionCollection;
+    public void Collide(uint collidingWith, ActorTypes type, OMV.Vector3 contactPoint, OMV.Vector3 contactNormal, float pentrationDepth)
+    {
+        // m_log.DebugFormat("{0}: Collide: ms={1}, id={2}, with={3}", LogHeader, _subscribedEventsMs, LocalID, collidingWith);
+
+        // The following lines make IsColliding() and IsCollidingGround() work
+        _collidingStep = _scene.SimulationStep;
+        if (collidingWith == BSScene.TERRAIN_ID || collidingWith == BSScene.GROUNDPLANE_ID)
+        {
+            _collidingGroundStep = _scene.SimulationStep;
+        }
+
+        // DetailLog("{0},BSPrim.Collison,call,with={1}", LocalID, collidingWith);
+
+        // if someone is subscribed to collision events....
+        if (_subscribedEventsMs != 0) {
+            // throttle the collisions to the number of milliseconds specified in the subscription
+            int nowTime = _scene.SimulationNowTime;
+            if (nowTime >= _nextCollisionOkTime) {
+                _nextCollisionOkTime = nowTime + _subscribedEventsMs;
 
-        // The linkset implimentation might want to know about this.
-        Linkset.UpdateProperties(this);
+                if (collisionCollection == null)
+                    collisionCollection = new CollisionEventUpdate();
+                collisionCollection.AddCollider(collidingWith, new ContactPoint(contactPoint, contactNormal, pentrationDepth));
+            }
+        }
+    }
+
+    // The scene is telling us it's time to pass our collected collisions into the simulator
+    public void SendCollisions()
+    {
+        if (collisionCollection != null && collisionCollection.Count > 0)
+        {
+            base.SendCollisionUpdate(collisionCollection);
+            // The collisionCollection structure is passed around in the simulator.
+            // Make sure we don't have a handle to that one and that a new one is used next time.
+            collisionCollection = null;
+        }
+    }
+
+    // Invoke the detailed logger and output something if it's enabled.
+    private void DetailLog(string msg, params Object[] args)
+    {
+        Scene.PhysicsLogging.Write(msg, args);
     }
 }
 }
diff --git a/OpenSim/Region/Physics/BulletSPlugin/BSScene.cs b/OpenSim/Region/Physics/BulletSPlugin/BSScene.cs
index 740f339..a31c578 100644
--- a/OpenSim/Region/Physics/BulletSPlugin/BSScene.cs
+++ b/OpenSim/Region/Physics/BulletSPlugin/BSScene.cs
@@ -39,88 +39,96 @@ using log4net;
 using OpenMetaverse;
 
 // TODOs for BulletSim (for BSScene, BSPrim, BSCharacter and BulletSim)
-// Test sculpties (verified that they don't work)
+// Debug linkset 
+// Test with multiple regions in one simulator 
+// Adjust character capsule size when height is adjusted (ScenePresence.SetHeight)
+// Test sculpties
 // Compute physics FPS reasonably
 // Based on material, set density and friction
-// Don't use constraints in linksets of non-physical objects. Means having to move children manually.
+// More efficient memory usage when passing hull information from BSPrim to BulletSim
+// Move all logic out of the C++ code and into the C# code for easier future modifications.
 // Four states of prim: Physical, regular, phantom and selected. Are we modeling these correctly?
 //     In SL one can set both physical and phantom (gravity, does not effect others, makes collisions with ground)
 //     At the moment, physical and phantom causes object to drop through the terrain
 // Physical phantom objects and related typing (collision options )
+// Use collision masks for collision with terrain and phantom objects 
 // Check out llVolumeDetect. Must do something for that.
-// Use collision masks for collision with terrain and phantom objects
-// More efficient memory usage when passing hull information from BSPrim to BulletSim
 // Should prim.link() and prim.delink() membership checking happen at taint time?
-// Mesh sharing. Use meshHash to tell if we already have a hull of that shape and only create once.
+// changing the position and orientation of a linked prim must rebuild the constraint with the root.
+// Mesh sharing. Use meshHash to tell if we already have a hull of that shape and only create once
 // Do attachments need to be handled separately? Need collision events. Do not collide with VolumeDetect
+// Implement the genCollisions feature in BulletSim::SetObjectProperties (don't pass up unneeded collisions)
 // Implement LockAngularMotion
 // Decide if clearing forces is the right thing to do when setting position (BulletSim::SetObjectTranslation)
+// Does NeedsMeshing() really need to exclude all the different shapes?
 // Remove mesh and Hull stuff. Use mesh passed to bullet and use convexdecom from bullet.
 // Add PID movement operations. What does ScenePresence.MoveToTarget do?
 // Check terrain size. 128 or 127?
 // Raycast
-//
+// 
 namespace OpenSim.Region.Physics.BulletSPlugin
 {
-public sealed class BSScene : PhysicsScene, IPhysicsParameters
+public class BSScene : PhysicsScene, IPhysicsParameters
 {
     private static readonly ILog m_log = LogManager.GetLogger(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType);
     private static readonly string LogHeader = "[BULLETS SCENE]";
 
-    // The name of the region we're working for.
-    public string RegionName { get; private set; }
+    public void DebugLog(string mm, params Object[] xx) { if (ShouldDebugLog) m_log.DebugFormat(mm, xx); }
 
     public string BulletSimVersion = "?";
 
-    public Dictionary<uint, BSPhysObject> PhysObjects;
-    public BSShapeCollection Shapes;
-
-    // Keeping track of the objects with collisions so we can report begin and end of a collision
-    public HashSet<BSPhysObject> ObjectsWithCollisions = new HashSet<BSPhysObject>();
-    public HashSet<BSPhysObject> ObjectsWithNoMoreCollisions = new HashSet<BSPhysObject>();
-    // 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>();
-
-    // List of all the objects that have vehicle properties and should be called
-    //    to update each physics step.
-    private List<BSPhysObject> m_vehicles = new List<BSPhysObject>();
+    private Dictionary<uint, BSCharacter> m_avatars = new Dictionary<uint, BSCharacter>();
+    private Dictionary<uint, BSPrim> m_prims = new Dictionary<uint, BSPrim>();
+    private HashSet<BSCharacter> m_avatarsWithCollisions = new HashSet<BSCharacter>();
+    private HashSet<BSPrim> m_primsWithCollisions = new HashSet<BSPrim>();
+    private List<BSPrim> m_vehicles = new List<BSPrim>();
+    private float[] m_heightMap;
+    private float m_waterLevel;
+    private uint m_worldID;
+    public uint WorldID { get { return m_worldID; } }
 
     // let my minuions use my logger
     public ILog Logger { get { return m_log; } }
 
-    public IMesher mesher;
-    // Level of Detail values kept as float because that's what the Meshmerizer wants
-    public float MeshLOD { get; private set; }
-    public float MeshMegaPrimLOD { get; private set; }
-    public float MeshMegaPrimThreshold { get; private set; }
-    public float SculptLOD { get; private set; }
+    private bool m_initialized = false;
 
-    public uint WorldID { get; private set; }
-    public BulletSim World { get; private set; }
+    private int m_detailedStatsStep = 0;
+
+    public IMesher mesher;
+    private float m_meshLOD;
+    public float MeshLOD
+    {
+        get { return m_meshLOD; }
+    }
+    private float m_sculptLOD;
+    public float SculptLOD
+    {
+        get { return m_sculptLOD; }
+    }
 
-    // All the constraints that have been allocated in this instance.
-    public BSConstraintCollection Constraints { get; private set; }
+    private BulletSim m_worldSim;
+    public BulletSim World
+    {
+        get { return m_worldSim; }
+    }
+    private BSConstraintCollection m_constraintCollection;
+    public BSConstraintCollection Constraints
+    { 
+        get { return m_constraintCollection; }
+    }
 
-    // Simulation parameters
     private int m_maxSubSteps;
     private float m_fixedTimeStep;
     private long m_simulationStep = 0;
     public long SimulationStep { get { return m_simulationStep; } }
-    private int m_taintsToProcessPerStep;
+
+    public float LastSimulatedTimestep { get; private set; }
 
     // A value of the time now so all the collision and update routines do not have to get their own
     // Set to 'now' just before all the prims and actors are called for collisions and updates
-    public int SimulationNowTime { get; private set; }
-
-    // True if initialized and ready to do simulation steps
-    private bool m_initialized = false;
-
-    // Flag which is true when processing taints.
-    // Not guaranteed to be correct all the time (don't depend on this) but good for debugging.
-    public bool InTaintTime { get; private set; }
+    private int m_simulationNowTime;
+    public int SimulationNowTime { get { return m_simulationNowTime; } }
 
-    // Pinned memory used to pass step information between managed and unmanaged
     private int m_maxCollisionsPerFrame;
     private CollisionDesc[] m_collisionArray;
     private GCHandle m_collisionArrayPinnedHandle;
@@ -129,19 +137,14 @@ public sealed class BSScene : PhysicsScene, IPhysicsParameters
     private EntityProperties[] m_updateArray;
     private GCHandle m_updateArrayPinnedHandle;
 
-    public bool ShouldMeshSculptedPrim { get; private set; }   // cause scuplted prims to get meshed
-    public bool ShouldForceSimplePrimMeshing { get; private set; }   // if a cube or sphere, let Bullet do internal shapes
-    public bool ShouldUseHullsForPhysicalObjects { get; private set; }   // 'true' if should create hulls for physical objects
+    private bool _meshSculptedPrim = true;         // cause scuplted prims to get meshed
+    private bool _forceSimplePrimMeshing = false;   // if a cube or sphere, let Bullet do internal shapes
 
     public float PID_D { get; private set; }    // derivative
     public float PID_P { get; private set; }    // proportional
 
     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
-
-    private float m_waterLevel;
-    public BSTerrainManager TerrainManager { get; private set; }
 
     public ConfigurationParameters Params
     {
@@ -151,18 +154,13 @@ public sealed class BSScene : PhysicsScene, IPhysicsParameters
     {
         get { return new Vector3(0f, 0f, Params.gravity); }
     }
-    // Just the Z value of the gravity
-    public float DefaultGravityZ
+
+    private float m_maximumObjectMass;
+    public float MaximumObjectMass
     {
-        get { return Params.gravity; }
+        get { return m_maximumObjectMass; }
     }
 
-    public float MaximumObjectMass { get; private set; }
-
-    // When functions in the unmanaged code must be called, it is only
-    //   done at a known time just before the simulation step. The taint
-    //   system saves all these function calls and executes them in
-    //   order before the simulation.
     public delegate void TaintCallback();
     private struct TaintCallbackEntry
     {
@@ -174,19 +172,15 @@ public sealed class BSScene : PhysicsScene, IPhysicsParameters
             callback = c;
         }
     }
-    private Object _taintLock = new Object();   // lock for using the next object
-    private List<TaintCallbackEntry> _taintOperations;
-    private Dictionary<string, TaintCallbackEntry> _postTaintOperations;
-    private List<TaintCallbackEntry> _postStepOperations;
+    private List<TaintCallbackEntry> _taintedObjects;
+    private Object _taintLock = new Object();
 
     // A pointer to an instance if this structure is passed to the C++ code
-    // Used to pass basic configuration values to the unmanaged code.
     ConfigurationParameters[] m_params;
     GCHandle m_paramsHandle;
 
-    // Handle to the callback used by the unmanaged code to call into the managed code.
-    // Used for debug logging.
-    // Need to store the handle in a persistant variable so it won't be freed.
+    public bool ShouldDebugLog { get; private set; }
+
     private BulletSimAPI.DebugLogCallback m_DebugLogCallbackHandle;
 
     // Sometimes you just have to log everything.
@@ -195,26 +189,17 @@ public sealed class BSScene : PhysicsScene, IPhysicsParameters
     private string m_physicsLoggingDir;
     private string m_physicsLoggingPrefix;
     private int m_physicsLoggingFileMinutes;
-    // 'true' of the vehicle code is to log lots of details
-    public bool VehicleLoggingEnabled { get; private set; }
 
-    #region Construction and Initialization
+    private bool m_vehicleLoggingEnabled;
+    public bool VehicleLoggingEnabled { get { return m_vehicleLoggingEnabled; } }
+
     public BSScene(string identifier)
     {
         m_initialized = false;
-        // we are passed the name of the region we're working for.
-        RegionName = identifier;
     }
 
     public override void Initialise(IMesher meshmerizer, IConfigSource config)
     {
-        mesher = meshmerizer;
-        _taintOperations = new List<TaintCallbackEntry>();
-        _postTaintOperations = new Dictionary<string, TaintCallbackEntry>();
-        _postStepOperations = new List<TaintCallbackEntry>();
-        PhysObjects = new Dictionary<uint, BSPhysObject>();
-        Shapes = new BSShapeCollection(this);
-
         // Allocate pinned memory to pass parameters.
         m_params = new ConfigurationParameters[1];
         m_paramsHandle = GCHandle.Alloc(m_params, GCHandleType.Pinned);
@@ -230,7 +215,7 @@ public sealed class BSScene : PhysicsScene, IPhysicsParameters
 
         // Enable very detailed logging.
         // By creating an empty logger when not logging, the log message invocation code
-        //     can be left in and every call doesn't have to check for null.
+        // can be left in and every call doesn't have to check for null.
         if (m_physicsLoggingEnabled)
         {
             PhysicsLogging = new Logging.LogWriter(m_physicsLoggingDir, m_physicsLoggingPrefix, m_physicsLoggingFileMinutes);
@@ -240,43 +225,39 @@ public sealed class BSScene : PhysicsScene, IPhysicsParameters
             PhysicsLogging = new Logging.LogWriter();
         }
 
-        // If Debug logging level, enable logging from the unmanaged code
-        m_DebugLogCallbackHandle = null;
+        // Get the version of the DLL
+        // TODO: this doesn't work yet. Something wrong with marshaling the returned string.
+        // BulletSimVersion = BulletSimAPI.GetVersion();
+        // m_log.WarnFormat("{0}: BulletSim.dll version='{1}'", LogHeader, BulletSimVersion);
+
+        // if Debug, enable logging from the unmanaged code
         if (m_log.IsDebugEnabled || PhysicsLogging.Enabled)
         {
             m_log.DebugFormat("{0}: Initialize: Setting debug callback for unmanaged code", LogHeader);
             if (PhysicsLogging.Enabled)
-                // The handle is saved in a variable to make sure it doesn't get freed after this call
                 m_DebugLogCallbackHandle = new BulletSimAPI.DebugLogCallback(BulletLoggerPhysLog);
             else
                 m_DebugLogCallbackHandle = new BulletSimAPI.DebugLogCallback(BulletLogger);
+            // the handle is saved in a variable to make sure it doesn't get freed after this call
+            BulletSimAPI.SetDebugLogCallback(m_DebugLogCallbackHandle);
         }
 
-        // Get the version of the DLL
-        // TODO: this doesn't work yet. Something wrong with marshaling the returned string.
-        // BulletSimVersion = BulletSimAPI.GetVersion();
-        // m_log.WarnFormat("{0}: BulletSim.dll version='{1}'", LogHeader, BulletSimVersion);
+        _taintedObjects = new List<TaintCallbackEntry>();
 
-        // The bounding box for the simulated world. The origin is 0,0,0 unless we're
-        //    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);
+        mesher = meshmerizer;
+        // The bounding box for the simulated world
+        Vector3 worldExtent = new Vector3(Constants.RegionSize, Constants.RegionSize, 8192f);
 
         // m_log.DebugFormat("{0}: Initialize: Calling BulletSimAPI.Initialize.", LogHeader);
-        World = new BulletSim(0, this, BulletSimAPI.Initialize2(worldExtent, m_paramsHandle.AddrOfPinnedObject(),
+        m_worldID = BulletSimAPI.Initialize(worldExtent, m_paramsHandle.AddrOfPinnedObject(),
                                         m_maxCollisionsPerFrame, m_collisionArrayPinnedHandle.AddrOfPinnedObject(),
-                                        m_maxUpdatesPerFrame, m_updateArrayPinnedHandle.AddrOfPinnedObject(),
-                                        m_DebugLogCallbackHandle));
-
-        Constraints = new BSConstraintCollection(World);
+                                        m_maxUpdatesPerFrame, m_updateArrayPinnedHandle.AddrOfPinnedObject());
 
-        TerrainManager = new BSTerrainManager(this);
-        TerrainManager.CreateInitialGroundPlaneAndTerrain();
+        // Initialization to support the transition to a new API which puts most of the logic
+        //   into the C# code so it is easier to modify and add to.
+        m_worldSim = new BulletSim(m_worldID, this, BulletSimAPI.GetSimHandle2(m_worldID));
+        m_constraintCollection = new BSConstraintCollection(World);
 
-        m_log.WarnFormat("{0} Linksets implemented with {1}", LogHeader, (BSLinkset.LinksetImplementation)Params.linksetImplementation);
-
-        InTaintTime = false;
         m_initialized = true;
     }
 
@@ -300,13 +281,10 @@ public sealed class BSScene : PhysicsScene, IPhysicsParameters
                 // Very detailed logging for physics debugging
                 m_physicsLoggingEnabled = pConfig.GetBoolean("PhysicsLoggingEnabled", false);
                 m_physicsLoggingDir = pConfig.GetString("PhysicsLoggingDir", ".");
-                m_physicsLoggingPrefix = pConfig.GetString("PhysicsLoggingPrefix", "physics-%REGIONNAME%-");
+                m_physicsLoggingPrefix = pConfig.GetString("PhysicsLoggingPrefix", "physics-");
                 m_physicsLoggingFileMinutes = pConfig.GetInt("PhysicsLoggingFileMinutes", 5);
                 // Very detailed logging for vehicle debugging
-                VehicleLoggingEnabled = pConfig.GetBoolean("VehicleLoggingEnabled", false);
-
-                // Do any replacements in the parameters
-                m_physicsLoggingPrefix = m_physicsLoggingPrefix.Replace("%REGIONNAME%", RegionName);
+                m_vehicleLoggingEnabled = pConfig.GetBoolean("VehicleLoggingEnabled", false);
             }
         }
     }
@@ -331,50 +309,12 @@ public sealed class BSScene : PhysicsScene, IPhysicsParameters
     {
         m_log.Debug("[BULLETS UNMANAGED]:" + msg);
     }
-
+    
     // Called directly from unmanaged code so don't do much
     private void BulletLoggerPhysLog(string msg)
     {
-        DetailLog("[BULLETS UNMANAGED]:" + msg);
-    }
-
-    public override void Dispose()
-    {
-        // m_log.DebugFormat("{0}: Dispose()", LogHeader);
-
-        // make sure no stepping happens while we're deleting stuff
-        m_initialized = false;
-
-        TerrainManager.ReleaseGroundPlaneAndTerrain();
-
-        foreach (KeyValuePair<uint, BSPhysObject> kvp in PhysObjects)
-        {
-            kvp.Value.Destroy();
-        }
-        PhysObjects.Clear();
-
-        // Now that the prims are all cleaned up, there should be no constraints left
-        if (Constraints != null)
-        {
-            Constraints.Dispose();
-            Constraints = null;
-        }
-
-        if (Shapes != null)
-        {
-            Shapes.Dispose();
-            Shapes = null;
-        }
-
-        // Anything left in the unmanaged code should be cleaned out
-        BulletSimAPI.Shutdown2(World.ptr);
-
-        // Not logging any more
-        PhysicsLogging.Close();
+        PhysicsLogging.Write("[BULLETS UNMANAGED]:" + msg);
     }
-    #endregion // Construction and Initialization
-
-    #region Prim and Avatar addition and removal
 
     public override PhysicsActor AddAvatar(string avName, Vector3 position, Vector3 size, bool isFlying)
     {
@@ -389,13 +329,7 @@ public sealed class BSScene : PhysicsScene, IPhysicsParameters
         if (!m_initialized) return null;
 
         BSCharacter actor = new BSCharacter(localID, avName, this, position, 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) m_avatars.Add(actor);
-
+        lock (m_avatars) m_avatars.Add(localID, actor);
         return actor;
     }
 
@@ -410,9 +344,7 @@ public sealed class BSScene : PhysicsScene, IPhysicsParameters
         {
             try
             {
-                lock (PhysObjects) PhysObjects.Remove(actor.LocalID);
-                // Remove kludge someday
-                lock (m_avatars) m_avatars.Remove(bsactor);
+                lock (m_avatars) m_avatars.Remove(actor.LocalID);
             }
             catch (Exception e)
             {
@@ -430,11 +362,11 @@ public sealed class BSScene : PhysicsScene, IPhysicsParameters
         BSPrim bsprim = prim as BSPrim;
         if (bsprim != null)
         {
-            DetailLog("{0},RemovePrim,call", bsprim.LocalID);
+            // DetailLog("{0},RemovePrim,call", bsprim.LocalID);
             // m_log.DebugFormat("{0}: RemovePrim. id={1}/{2}", LogHeader, bsprim.Name, bsprim.LocalID);
             try
             {
-                lock (PhysObjects) PhysObjects.Remove(bsprim.LocalID);
+                lock (m_prims) m_prims.Remove(bsprim.LocalID);
             }
             catch (Exception e)
             {
@@ -456,21 +388,18 @@ public sealed class BSScene : PhysicsScene, IPhysicsParameters
 
         if (!m_initialized) return null;
 
-        DetailLog("{0},AddPrimShape,call", localID);
+        // DetailLog("{0},AddPrimShape,call", localID);
 
         BSPrim prim = new BSPrim(localID, primName, this, position, size, rotation, pbs, isPhysical);
-        lock (PhysObjects) PhysObjects.Add(localID, prim);
+        lock (m_prims) m_prims.Add(localID, prim);
         return prim;
     }
 
     // This is a call from the simulator saying that some physical property has been updated.
-    // The BulletSim driver senses the changing of relevant properties so this taint
+    // The BulletSim driver senses the changing of relevant properties so this taint 
     // information call is not needed.
     public override void AddPhysicsActorTaint(PhysicsActor prim) { }
 
-    #endregion // Prim and Avatar addition and removal
-
-    #region Simulation
     // Simulate one timestep
     public override float Simulate(float timeStep)
     {
@@ -479,45 +408,34 @@ public sealed class BSScene : PhysicsScene, IPhysicsParameters
         int collidersCount = 0;
         IntPtr collidersPtr;
 
-        int beforeTime = 0;
-        int simTime = 0;
+        LastSimulatedTimestep = timeStep;
 
         // prevent simulation until we've been initialized
-        if (!m_initialized) return 5.0f;
+        if (!m_initialized) return 10.0f;
+
+        int simulateStartTime = Util.EnvironmentTickCount();
 
         // update the prim states while we know the physics engine is not busy
-        int numTaints = _taintOperations.Count;
         ProcessTaints();
 
         // Some of the prims operate with special vehicle properties
         ProcessVehicles(timeStep);
-        numTaints += _taintOperations.Count;
         ProcessTaints();    // the vehicles might have added taints
 
         // step the physical world one interval
         m_simulationStep++;
         int numSubSteps = 0;
-
         try
         {
-            // DumpVehicles();  // DEBUG
-            if (PhysicsLogging.Enabled) beforeTime = Util.EnvironmentTickCount();
-
-            numSubSteps = BulletSimAPI.PhysicsStep2(World.ptr, timeStep, m_maxSubSteps, m_fixedTimeStep,
+            numSubSteps = BulletSimAPI.PhysicsStep(m_worldID, timeStep, m_maxSubSteps, m_fixedTimeStep,
                         out updatedEntityCount, out updatedEntitiesPtr, out collidersCount, out collidersPtr);
-
-            if (PhysicsLogging.Enabled) simTime = Util.EnvironmentTickCountSubtract(beforeTime);
-            DetailLog("{0},Simulate,call, frame={1}, nTaints={2}, simTime={3}, substeps={4}, updates={5}, colliders={6}",
-                        DetailLogZero, m_simulationStep, numTaints, simTime, numSubSteps, updatedEntityCount, collidersCount);
-            // DumpVehicles();  // DEBUG
+            // DetailLog("{0},Simulate,call, substeps={1}, updates={2}, colliders={3}", DetailLogZero, numSubSteps, updatedEntityCount, collidersCount); 
         }
         catch (Exception e)
         {
-            m_log.WarnFormat("{0},PhysicsStep Exception: nTaints={1}, substeps={2}, updates={3}, colliders={4}, e={5}",
-                        LogHeader, numTaints, numSubSteps, updatedEntityCount, collidersCount, e);
-            DetailLog("{0},PhysicsStepException,call, nTaints={1}, substeps={2}, updates={3}, colliders={4}",
-                        DetailLogZero, numTaints, numSubSteps, updatedEntityCount, collidersCount);
-            updatedEntityCount = 0;
+            m_log.WarnFormat("{0},PhysicsStep Exception: substeps={1}, updates={2}, colliders={3}, e={4}", LogHeader, numSubSteps, updatedEntityCount, collidersCount, e);
+            // DetailLog("{0},PhysicsStepException,call, substeps={1}, updates={2}, colliders={3}", DetailLogZero, numSubSteps, updatedEntityCount, collidersCount);
+            // updatedEntityCount = 0;
             collidersCount = 0;
         }
 
@@ -525,7 +443,7 @@ public sealed class BSScene : PhysicsScene, IPhysicsParameters
         // Don't have to use the pointers passed back since we know it is the same pinned memory we passed in
 
         // Get a value for 'now' so all the collision and update routines don't have to get their own
-        SimulationNowTime = Util.EnvironmentTickCount();
+        m_simulationNowTime = Util.EnvironmentTickCount();
 
         // If there were collisions, process them by sending the event to the prim.
         // Collisions must be processed before updates.
@@ -544,32 +462,19 @@ public sealed class BSScene : PhysicsScene, IPhysicsParameters
 
         // The above SendCollision's batch up the collisions on the objects.
         //      Now push the collisions into the simulator.
-        if (ObjectsWithCollisions.Count > 0)
-        {
-            foreach (BSPhysObject bsp in ObjectsWithCollisions)
-                if (!bsp.SendCollisions())
-                {
-                    // If the object is done colliding, see that it's removed from the colliding list
-                    ObjectsWithNoMoreCollisions.Add(bsp);
-                }
-        }
-
-        // This is a kludge to get avatar movement updates.
-        // The simulator expects collisions for avatars even if there are have been no collisions.
-        //    The event updates avatar animations and stuff.
-        // If you fix avatar animation updates, remove this overhead and let normal collision processing happen.
-        foreach (BSPhysObject bsp in m_avatars)
-            if (!ObjectsWithCollisions.Contains(bsp))   // don't call avatars twice
-                bsp.SendCollisions();
-
-        // Objects that are done colliding are removed from the ObjectsWithCollisions list.
-        // Not done above because it is inside an iteration of ObjectWithCollisions.
-        if (ObjectsWithNoMoreCollisions.Count > 0)
-        {
-            foreach (BSPhysObject po in ObjectsWithNoMoreCollisions)
-                ObjectsWithCollisions.Remove(po);
-            ObjectsWithNoMoreCollisions.Clear();
-        }
+        foreach (BSPrim bsp in m_primsWithCollisions)
+            bsp.SendCollisions();
+        m_primsWithCollisions.Clear();
+
+        // This is a kludge to get avatar movement updated. 
+        //   Don't send collisions only if there were collisions -- send everytime.
+        //   ODE sends collisions even if there are none and this is used to update
+        //   avatar animations and stuff.
+        // foreach (BSCharacter bsc in m_avatarsWithCollisions)
+        //     bsc.SendCollisions();
+        foreach (KeyValuePair<uint, BSCharacter> kvp in m_avatars)
+            kvp.Value.SendCollisions();
+        m_avatarsWithCollisions.Clear();
 
         // If any of the objects had updated properties, tell the object it has been changed by the physics engine
         if (updatedEntityCount > 0)
@@ -577,310 +482,320 @@ public sealed class BSScene : PhysicsScene, IPhysicsParameters
             for (int ii = 0; ii < updatedEntityCount; ii++)
             {
                 EntityProperties entprop = m_updateArray[ii];
-                BSPhysObject pobj;
-                if (PhysObjects.TryGetValue(entprop.ID, out pobj))
+                BSPrim prim;
+                if (m_prims.TryGetValue(entprop.ID, out prim))
+                {
+                    prim.UpdateProperties(entprop);
+                    continue;
+                }
+                BSCharacter actor;
+                if (m_avatars.TryGetValue(entprop.ID, out actor))
                 {
-                    pobj.UpdateProperties(entprop);
+                    actor.UpdateProperties(entprop);
+                    continue;
                 }
             }
         }
 
-        ProcessPostStepTaints();
-
-        // This causes the unmanaged code to output ALL the values found in ALL the objects in the world.
-        // Only enable this in a limited test world with few objects.
-        // BulletSimAPI.DumpAllInfo2(World.ptr);    // DEBUG DEBUG DEBUG
+        // If enabled, call into the physics engine to dump statistics
+        if (m_detailedStatsStep > 0)
+        {
+            if ((m_simulationStep % m_detailedStatsStep) == 0)
+            {
+                BulletSimAPI.DumpBulletStatistics();
+            }
+        }
 
-        // The physics engine returns the number of milliseconds it simulated this call.
-        // These are summed and normalized to one second and divided by 1000 to give the reported physics FPS.
-        // We multiply by 55 to give a recognizable running rate (55 or less).
-        return numSubSteps * m_fixedTimeStep * 1000 * 55;
-        // return timeStep * 1000 * 55;
+        // this is a waste since the outside routine also calcuates the physics simulation
+        //   period. TODO: There should be a way of computing physics frames from simulator computation.
+        // long simulateTotalTime = Util.EnvironmentTickCountSubtract(simulateStartTime);
+        // return (timeStep * (float)simulateTotalTime);
+
+        // TODO: FIX THIS: fps calculation possibly wrong.
+        // This calculation says 1/timeStep is the ideal frame rate. Any time added to
+        //    that by the physics simulation gives a slower frame rate.
+        long totalSimulationTime = Util.EnvironmentTickCountSubtract(simulateStartTime);
+        if (totalSimulationTime >= timeStep)
+            return 0;
+        return 1f / (timeStep + totalSimulationTime);
     }
 
     // Something has collided
-    private void SendCollision(uint localID, uint collidingWith, Vector3 collidePoint, Vector3 collideNormal, float penetration)
+    private void SendCollision(uint localID, uint collidingWith, Vector3 collidePoint, Vector3 collideNormal, float penitration)
     {
-        if (localID <= TerrainManager.HighestTerrainID)
+        if (localID == TERRAIN_ID || localID == GROUNDPLANE_ID)
         {
             return;         // don't send collisions to the terrain
         }
 
-        BSPhysObject collider;
-        if (!PhysObjects.TryGetValue(localID, out collider))
-        {
-            // If the object that is colliding cannot be found, just ignore the collision.
-            DetailLog("{0},BSScene.SendCollision,colliderNotInObjectList,id={1},with={2}", DetailLogZero, localID, collidingWith);
+        ActorTypes type = ActorTypes.Prim;
+        if (collidingWith == TERRAIN_ID || collidingWith == GROUNDPLANE_ID)
+            type = ActorTypes.Ground;
+        else if (m_avatars.ContainsKey(collidingWith))
+            type = ActorTypes.Agent;
+
+        BSPrim prim;
+        if (m_prims.TryGetValue(localID, out prim)) {
+            prim.Collide(collidingWith, type, collidePoint, collideNormal, penitration);
+            m_primsWithCollisions.Add(prim);
             return;
         }
-
-        // The terrain is not in the physical object list so 'collidee' can be null when Collide() is called.
-        BSPhysObject collidee = null;
-        PhysObjects.TryGetValue(collidingWith, out collidee);
-
-        // DetailLog("{0},BSScene.SendCollision,collide,id={1},with={2}", DetailLogZero, localID, collidingWith);
-
-        if (collider.Collide(collidingWith, collidee, collidePoint, collideNormal, penetration))
-        {
-            // If a collision was posted, remember to send it to the simulator
-            ObjectsWithCollisions.Add(collider);
+        BSCharacter actor;
+        if (m_avatars.TryGetValue(localID, out actor)) {
+            actor.Collide(collidingWith, type, collidePoint, collideNormal, penitration);
+            m_avatarsWithCollisions.Add(actor);
+            return;
         }
-
         return;
     }
 
-    #endregion // Simulation
-
     public override void GetResults() { }
 
-    #region Terrain
-
     public override void SetTerrain(float[] heightMap) {
-        TerrainManager.SetTerrain(heightMap);
+        m_heightMap = heightMap;
+        this.TaintedObject("BSScene.SetTerrain", delegate()
+        {
+            BulletSimAPI.SetHeightmap(m_worldID, m_heightMap);
+        });
     }
 
-    public override void SetWaterLevel(float baseheight)
+    // Someday we will have complex terrain with caves and tunnels
+    // For the moment, it's flat and convex
+    public float GetTerrainHeightAtXYZ(Vector3 loc)
     {
-        m_waterLevel = baseheight;
-    }
-    // Someday....
-    public float GetWaterLevelAtXYZ(Vector3 loc)
-    {
-        return m_waterLevel;
+        return GetTerrainHeightAtXY(loc.X, loc.Y);
     }
 
-    public override void DeleteTerrain()
+    public float GetTerrainHeightAtXY(float tX, float tY)
     {
-        // m_log.DebugFormat("{0}: DeleteTerrain()", LogHeader);
+        if (tX < 0 || tX >= Constants.RegionSize || tY < 0 || tY >= Constants.RegionSize)
+            return 30;
+        return m_heightMap[((int)tX) * Constants.RegionSize + ((int)tY)];
     }
 
-    // Although no one seems to check this, I do support combining.
-    public override bool SupportsCombining()
+    public override void SetWaterLevel(float baseheight) 
     {
-        return TerrainManager.SupportsCombining();
+        m_waterLevel = baseheight;
+        // TODO: pass to physics engine so things will float?
     }
-    // This call says I am a child to region zero in a mega-region. 'pScene' is that
-    //    of region zero, 'offset' is my offset from regions zero's origin, and
-    //    'extents' is the largest XY that is handled in my region.
-    public override void Combine(PhysicsScene pScene, Vector3 offset, Vector3 extents)
+    public float GetWaterLevel()
     {
-        TerrainManager.Combine(pScene, offset, extents);
+        return m_waterLevel;
     }
 
-    // Unhook all the combining that I know about.
-    public override void UnCombine(PhysicsScene pScene)
+    public override void DeleteTerrain() 
     {
-        TerrainManager.UnCombine(pScene);
+        // m_log.DebugFormat("{0}: DeleteTerrain()", LogHeader);
     }
 
-    #endregion // Terrain
-
-    public override Dictionary<uint, float> GetTopColliders()
+    public override void Dispose()
     {
-        return new Dictionary<uint, float>();
-    }
+        // m_log.DebugFormat("{0}: Dispose()", LogHeader);
 
-    public override bool IsThreaded { get { return false;  } }
+        // make sure no stepping happens while we're deleting stuff
+        m_initialized = false;
 
-    #region Taints
+        foreach (KeyValuePair<uint, BSCharacter> kvp in m_avatars)
+        {
+            kvp.Value.Destroy();
+        }
+        m_avatars.Clear();
 
-    // Calls to the PhysicsActors can't directly call into the physics engine
-    // because it might be busy. We delay changes to a known time.
-    // We rely on C#'s closure to save and restore the context for the delegate.
-    public void TaintedObject(String ident, TaintCallback callback)
-    {
-        if (!m_initialized) return;
+        foreach (KeyValuePair<uint, BSPrim> kvp in m_prims)
+        {
+            kvp.Value.Destroy();
+        }
+        m_prims.Clear();
 
-        lock (_taintLock)
+        // Now that the prims are all cleaned up, there should be no constraints left
+        if (m_constraintCollection != null)
         {
-            _taintOperations.Add(new TaintCallbackEntry(ident, callback));
+            m_constraintCollection.Dispose();
+            m_constraintCollection = null;
         }
 
-        return;
-    }
+        // Anything left in the unmanaged code should be cleaned out
+        BulletSimAPI.Shutdown(WorldID);
 
-    // Sometimes a potentially tainted operation can be used in and out of taint time.
-    // This routine executes the command immediately if in taint-time otherwise it is queued.
-    public void TaintedObject(bool inTaintTime, string ident, TaintCallback callback)
-    {
-        if (inTaintTime)
-            callback();
-        else
-            TaintedObject(ident, callback);
+        // Not logging any more
+        PhysicsLogging.Close();
     }
 
-    // When someone tries to change a property on a BSPrim or BSCharacter, the object queues
-    // a callback into itself to do the actual property change. That callback is called
-    // here just before the physics engine is called to step the simulation.
-    public void ProcessTaints()
+    public override Dictionary<uint, float> GetTopColliders()
     {
-        InTaintTime = true;
-        ProcessRegularTaints();
-        ProcessPostTaintTaints();
-        InTaintTime = false;
+        return new Dictionary<uint, float>();
     }
 
-    private void ProcessRegularTaints()
+    public override bool IsThreaded { get { return false;  } }
+
+    /// <summary>
+    /// Routine to figure out if we need to mesh this prim with our mesher
+    /// </summary>
+    /// <param name="pbs"></param>
+    /// <returns>true if the prim needs meshing</returns>
+    public bool NeedsMeshing(PrimitiveBaseShape pbs)
     {
-        if (_taintOperations.Count > 0)  // save allocating new list if there is nothing to process
+        // most of this is redundant now as the mesher will return null if it cant mesh a prim
+        // but we still need to check for sculptie meshing being enabled so this is the most
+        // convenient place to do it for now...
+
+        // int iPropertiesNotSupportedDefault = 0;
+
+        if (pbs.SculptEntry && !_meshSculptedPrim)
         {
-            int taintCount = m_taintsToProcessPerStep;
-            TaintCallbackEntry oneCallback = new TaintCallbackEntry();
-            while (_taintOperations.Count > 0 && taintCount-- > 0)
+            // Render sculpties as boxes
+            return false;
+        }
+
+        // if it's a standard box or sphere with no cuts, hollows, twist or top shear, return false since Bullet 
+        // can use an internal representation for the prim
+        if (!_forceSimplePrimMeshing)
+        {
+            if ((pbs.ProfileShape == ProfileShape.Square && pbs.PathCurve == (byte)Extrusion.Straight)
+                || (pbs.ProfileShape == ProfileShape.HalfCircle && pbs.PathCurve == (byte)Extrusion.Curve1
+                        && pbs.Scale.X == pbs.Scale.Y && pbs.Scale.Y == pbs.Scale.Z))
             {
-                bool gotOne = false;
-                lock (_taintLock)
-                {
-                    if (_taintOperations.Count > 0)
-                    {
-                        oneCallback = _taintOperations[0];
-                        _taintOperations.RemoveAt(0);
-                        gotOne = true;
-                    }
-                }
-                if (gotOne)
+
+                if (pbs.ProfileBegin == 0 && pbs.ProfileEnd == 0
+                    && pbs.ProfileHollow == 0
+                    && pbs.PathTwist == 0 && pbs.PathTwistBegin == 0
+                    && pbs.PathBegin == 0 && pbs.PathEnd == 0
+                    && pbs.PathTaperX == 0 && pbs.PathTaperY == 0
+                    && pbs.PathScaleX == 100 && pbs.PathScaleY == 100
+                    && pbs.PathShearX == 0 && pbs.PathShearY == 0)
                 {
-                    try
-                    {
-                        DetailLog("{0},BSScene.ProcessTaints,doTaint,id={1}", DetailLogZero, oneCallback.ident);
-                        oneCallback.callback();
-                    }
-                    catch (Exception e)
-                    {
-                        DetailLog("{0},BSScene.ProcessTaints,doTaintException,id={1}", DetailLogZero, oneCallback.ident); // DEBUG DEBUG DEBUG
-                        m_log.ErrorFormat("{0}: ProcessTaints: {1}: Exception: {2}", LogHeader, oneCallback.ident, e);
-                    }
+                    return false;
                 }
             }
-            /*
-            // swizzle a new list into the list location so we can process what's there
-            List<TaintCallbackEntry> oldList;
-            lock (_taintLock)
+        }
+
+        /*  TODO: verify that the mesher will now do all these shapes
+        if (pbs.ProfileHollow != 0)
+            iPropertiesNotSupportedDefault++;
+
+        if ((pbs.PathBegin != 0) || pbs.PathEnd != 0)
+            iPropertiesNotSupportedDefault++;
+
+        if ((pbs.PathTwistBegin != 0) || (pbs.PathTwist != 0))
+            iPropertiesNotSupportedDefault++; 
+
+        if ((pbs.ProfileBegin != 0) || pbs.ProfileEnd != 0)
+            iPropertiesNotSupportedDefault++;
+
+        if ((pbs.PathScaleX != 100) || (pbs.PathScaleY != 100))
+            iPropertiesNotSupportedDefault++;
+
+        if ((pbs.PathShearX != 0) || (pbs.PathShearY != 0))
+            iPropertiesNotSupportedDefault++;
+
+        if (pbs.ProfileShape == ProfileShape.Circle && pbs.PathCurve == (byte)Extrusion.Straight)
+            iPropertiesNotSupportedDefault++;
+
+        if (pbs.ProfileShape == ProfileShape.HalfCircle && pbs.PathCurve == (byte)Extrusion.Curve1 && (pbs.Scale.X != pbs.Scale.Y || pbs.Scale.Y != pbs.Scale.Z || pbs.Scale.Z != pbs.Scale.X))
+            iPropertiesNotSupportedDefault++;
+
+        if (pbs.ProfileShape == ProfileShape.HalfCircle && pbs.PathCurve == (byte) Extrusion.Curve1)
+            iPropertiesNotSupportedDefault++;
+
+        // test for torus
+        if ((pbs.ProfileCurve & 0x07) == (byte)ProfileShape.Square)
+        {
+            if (pbs.PathCurve == (byte)Extrusion.Curve1)
             {
-                oldList = _taintedObjects;
-                _taintedObjects = new List<TaintCallbackEntry>();
+                iPropertiesNotSupportedDefault++;
             }
-
-            foreach (TaintCallbackEntry tcbe in oldList)
+        }
+        else if ((pbs.ProfileCurve & 0x07) == (byte)ProfileShape.Circle)
+        {
+            if (pbs.PathCurve == (byte)Extrusion.Straight)
             {
-                try
-                {
-                    DetailLog("{0},BSScene.ProcessTaints,doTaint,id={1}", DetailLogZero, tcbe.ident); // DEBUG DEBUG DEBUG
-                    tcbe.callback();
-                }
-                catch (Exception e)
-                {
-                    m_log.ErrorFormat("{0}: ProcessTaints: {1}: Exception: {2}", LogHeader, tcbe.ident, e);
-                }
+                iPropertiesNotSupportedDefault++;
+            }
+            // ProfileCurve seems to combine hole shape and profile curve so we need to only compare against the lower 3 bits
+            else if (pbs.PathCurve == (byte)Extrusion.Curve1)
+            {
+                iPropertiesNotSupportedDefault++;
             }
-            oldList.Clear();
-             */
         }
-    }
-
-    // Schedule an update to happen after all the regular taints are processed.
-    // Note that new requests for the same operation ("ident") for the same object ("ID")
-    //     will replace any previous operation by the same object.
-    public void PostTaintObject(String ident, uint ID, TaintCallback callback)
-    {
-        if (!m_initialized) return;
-
-        string uniqueIdent = ident + "-" + ID.ToString();
-        lock (_taintLock)
+        else if ((pbs.ProfileCurve & 0x07) == (byte)ProfileShape.HalfCircle)
         {
-            _postTaintOperations[uniqueIdent] = new TaintCallbackEntry(uniqueIdent, callback);
+            if (pbs.PathCurve == (byte)Extrusion.Curve1 || pbs.PathCurve == (byte)Extrusion.Curve2)
+            {
+                iPropertiesNotSupportedDefault++;
+            }
         }
-
-        return;
-    }
-
-    private void ProcessPostTaintTaints()
-    {
-        if (_postTaintOperations.Count > 0)
+        else if ((pbs.ProfileCurve & 0x07) == (byte)ProfileShape.EquilateralTriangle)
         {
-            Dictionary<string, TaintCallbackEntry> oldList;
-            lock (_taintLock)
+            if (pbs.PathCurve == (byte)Extrusion.Straight)
             {
-                oldList = _postTaintOperations;
-                _postTaintOperations = new Dictionary<string, TaintCallbackEntry>();
+                iPropertiesNotSupportedDefault++;
             }
-
-            foreach (KeyValuePair<string,TaintCallbackEntry> kvp in oldList)
+            else if (pbs.PathCurve == (byte)Extrusion.Curve1)
             {
-                try
-                {
-                    DetailLog("{0},BSScene.ProcessPostTaintTaints,doTaint,id={1}", DetailLogZero, kvp.Key); // DEBUG DEBUG DEBUG
-                    kvp.Value.callback();
-                }
-                catch (Exception e)
-                {
-                    m_log.ErrorFormat("{0}: ProcessPostTaintTaints: {1}: Exception: {2}", LogHeader, kvp.Key, e);
-                }
+                iPropertiesNotSupportedDefault++;
             }
-            oldList.Clear();
         }
+        if (iPropertiesNotSupportedDefault == 0)
+        {
+            return false;
+        }
+         */
+        return true; 
     }
 
-    public void PostStepTaintObject(String ident, TaintCallback callback)
+    // Calls to the PhysicsActors can't directly call into the physics engine
+    // because it might be busy. We delay changes to a known time.
+    // We rely on C#'s closure to save and restore the context for the delegate.
+    public void TaintedObject(String ident, TaintCallback callback)
     {
         if (!m_initialized) return;
 
         lock (_taintLock)
-        {
-            _postStepOperations.Add(new TaintCallbackEntry(ident, callback));
-        }
-
+            _taintedObjects.Add(new TaintCallbackEntry(ident, callback));
         return;
     }
 
-    private void ProcessPostStepTaints()
+    // When someone tries to change a property on a BSPrim or BSCharacter, the object queues
+    // a callback into itself to do the actual property change. That callback is called
+    // here just before the physics engine is called to step the simulation.
+    public void ProcessTaints()
     {
-        if (_postStepOperations.Count > 0)
+        if (_taintedObjects.Count > 0)  // save allocating new list if there is nothing to process
         {
+            // swizzle a new list into the list location so we can process what's there
             List<TaintCallbackEntry> oldList;
             lock (_taintLock)
             {
-                oldList = _postStepOperations;
-                _postStepOperations = new List<TaintCallbackEntry>();
+                oldList = _taintedObjects;
+                _taintedObjects = new List<TaintCallbackEntry>();
             }
 
             foreach (TaintCallbackEntry tcbe in oldList)
             {
                 try
                 {
-                    DetailLog("{0},BSScene.ProcessPostStepTaints,doTaint,id={1}", DetailLogZero, tcbe.ident); // DEBUG DEBUG DEBUG
                     tcbe.callback();
                 }
                 catch (Exception e)
                 {
-                    m_log.ErrorFormat("{0}: ProcessPostStepTaints: {1}: Exception: {2}", LogHeader, tcbe.ident, e);
+                    m_log.ErrorFormat("{0}: ProcessTaints: {1}: Exception: {2}", LogHeader, tcbe.ident, e);
                 }
             }
             oldList.Clear();
         }
     }
 
-    public bool AssertInTaintTime(string whereFrom)
-    {
-        if (!InTaintTime)
-        {
-            DetailLog("{0},BSScene.AssertInTaintTime,NOT IN TAINT TIME,Region={1},Where={2}", DetailLogZero, RegionName, whereFrom);
-            m_log.ErrorFormat("{0} NOT IN TAINT TIME!! Region={1}, Where={2}", LogHeader, RegionName, whereFrom);
-            Util.PrintCallStack();
-        }
-        return InTaintTime;
-    }
-
-    #endregion // Taints
-
     #region Vehicles
 
     public void VehicleInSceneTypeChanged(BSPrim vehic, Vehicle newType)
     {
-        RemoveVehiclePrim(vehic);
-        if (newType != Vehicle.TYPE_NONE)
+        if (newType == Vehicle.TYPE_NONE)
         {
-           // make it so the scene will call us each tick to do vehicle things
+            RemoveVehiclePrim(vehic);
+        }
+        else
+        {
+            // make it so the scene will call us each tick to do vehicle things
            AddVehiclePrim(vehic);
         }
     }
@@ -912,22 +827,21 @@ public sealed class BSScene : PhysicsScene, IPhysicsParameters
     }
 
     // Some prims have extra vehicle actions
-    // Called at taint time!
+    // no locking because only called when physics engine is not busy
     private void ProcessVehicles(float timeStep)
     {
-        foreach (BSPhysObject pobj in m_vehicles)
+        foreach (BSPrim prim in m_vehicles)
         {
-            pobj.StepVehicle(timeStep);
+            prim.StepVehicle(timeStep);
         }
     }
     #endregion Vehicles
 
-    #region INI and command line parameter processing
+    #region Parameters
 
     delegate void ParamUser(BSScene scene, IConfig conf, string paramName, float val);
     delegate float ParamGet(BSScene scene);
     delegate void ParamSet(BSScene scene, string paramName, uint localID, float val);
-    delegate void SetOnObject(BSScene scene, BSPhysObject obj, float val);
 
     private struct ParameterDefn
     {
@@ -937,7 +851,6 @@ public sealed class BSScene : PhysicsScene, IPhysicsParameters
         public ParamUser userParam; // get the value from the configuration file
         public ParamGet getter;     // return the current value stored for this parameter
         public ParamSet setter;     // set the current value for this parameter
-        public SetOnObject onObject;    // set the value on an object in the physical domain
         public ParameterDefn(string n, string d, float v, ParamUser u, ParamGet g, ParamSet s)
         {
             name = n;
@@ -946,17 +859,6 @@ public sealed class BSScene : PhysicsScene, IPhysicsParameters
             userParam = u;
             getter = g;
             setter = s;
-            onObject = null;
-        }
-        public ParameterDefn(string n, string d, float v, ParamUser u, ParamGet g, ParamSet s, SetOnObject o)
-        {
-            name = n;
-            desc = d;
-            defaultValue = v;
-            userParam = u;
-            getter = g;
-            setter = s;
-            onObject = o;
         }
     }
 
@@ -967,7 +869,7 @@ public sealed class BSScene : PhysicsScene, IPhysicsParameters
     //    getters and setters.
     // It is easiest to find an existing definition and copy it.
     // Parameter values are floats. Booleans are converted to a floating value.
-    //
+    // 
     // A ParameterDefn() takes the following parameters:
     //    -- the text name of the parameter. This is used for console input and ini file.
     //    -- a short text description of the parameter. This shows up in the console listing.
@@ -978,7 +880,6 @@ public sealed class BSScene : PhysicsScene, IPhysicsParameters
     //
     // The single letter parameters for the delegates are:
     //    s = BSScene
-    //    o = BSPhysObject
     //    p = string parameter name
     //    l = localID of referenced object
     //    v = float value
@@ -987,40 +888,25 @@ public sealed class BSScene : PhysicsScene, IPhysicsParameters
     {
         new ParameterDefn("MeshSculptedPrim", "Whether to create meshes for sculpties",
             ConfigurationParameters.numericTrue,
-            (s,cf,p,v) => { s.ShouldMeshSculptedPrim = cf.GetBoolean(p, s.BoolNumeric(v)); },
-            (s) => { return s.NumericBool(s.ShouldMeshSculptedPrim); },
-            (s,p,l,v) => { s.ShouldMeshSculptedPrim = s.BoolNumeric(v); } ),
+            (s,cf,p,v) => { s._meshSculptedPrim = cf.GetBoolean(p, s.BoolNumeric(v)); },
+            (s) => { return s.NumericBool(s._meshSculptedPrim); },
+            (s,p,l,v) => { s._meshSculptedPrim = s.BoolNumeric(v); } ),
         new ParameterDefn("ForceSimplePrimMeshing", "If true, only use primitive meshes for objects",
             ConfigurationParameters.numericFalse,
-            (s,cf,p,v) => { s.ShouldForceSimplePrimMeshing = cf.GetBoolean(p, s.BoolNumeric(v)); },
-            (s) => { return s.NumericBool(s.ShouldForceSimplePrimMeshing); },
-            (s,p,l,v) => { s.ShouldForceSimplePrimMeshing = s.BoolNumeric(v); } ),
-        new ParameterDefn("UseHullsForPhysicalObjects", "If true, create hulls for physical objects",
-            ConfigurationParameters.numericTrue,
-            (s,cf,p,v) => { s.ShouldUseHullsForPhysicalObjects = cf.GetBoolean(p, s.BoolNumeric(v)); },
-            (s) => { return s.NumericBool(s.ShouldUseHullsForPhysicalObjects); },
-            (s,p,l,v) => { s.ShouldUseHullsForPhysicalObjects = s.BoolNumeric(v); } ),
+            (s,cf,p,v) => { s._forceSimplePrimMeshing = cf.GetBoolean(p, s.BoolNumeric(v)); },
+            (s) => { return s.NumericBool(s._forceSimplePrimMeshing); },
+            (s,p,l,v) => { s._forceSimplePrimMeshing = s.BoolNumeric(v); } ),
 
-        new ParameterDefn("MeshLevelOfDetail", "Level of detail to render meshes (32, 16, 8 or 4. 32=most detailed)",
+        new ParameterDefn("MeshLOD", "Level of detail to render meshes (32, 16, 8 or 4. 32=most detailed)",
             8f,
-            (s,cf,p,v) => { s.MeshLOD = (float)cf.GetInt(p, (int)v); },
-            (s) => { return s.MeshLOD; },
-            (s,p,l,v) => { s.MeshLOD = v; } ),
-        new ParameterDefn("MeshLevelOfDetailMegaPrim", "Level of detail to render meshes larger than threshold meters",
-            16f,
-            (s,cf,p,v) => { s.MeshMegaPrimLOD = (float)cf.GetInt(p, (int)v); },
-            (s) => { return s.MeshMegaPrimLOD; },
-            (s,p,l,v) => { s.MeshMegaPrimLOD = v; } ),
-        new ParameterDefn("MeshLevelOfDetailMegaPrimThreshold", "Size (in meters) of a mesh before using MeshMegaPrimLOD",
-            10f,
-            (s,cf,p,v) => { s.MeshMegaPrimThreshold = (float)cf.GetInt(p, (int)v); },
-            (s) => { return s.MeshMegaPrimThreshold; },
-            (s,p,l,v) => { s.MeshMegaPrimThreshold = v; } ),
-        new ParameterDefn("SculptLevelOfDetail", "Level of detail to render sculpties (32, 16, 8 or 4. 32=most detailed)",
+            (s,cf,p,v) => { s.m_meshLOD = cf.GetInt(p, (int)v); },
+            (s) => { return (float)s.m_meshLOD; },
+            (s,p,l,v) => { s.m_meshLOD = (int)v; } ),
+        new ParameterDefn("SculptLOD", "Level of detail to render sculpties (32, 16, 8 or 4. 32=most detailed)",
             32f,
-            (s,cf,p,v) => { s.SculptLOD = (float)cf.GetInt(p, (int)v); },
-            (s) => { return s.SculptLOD; },
-            (s,p,l,v) => { s.SculptLOD = v; } ),
+            (s,cf,p,v) => { s.m_sculptLOD = cf.GetInt(p, (int)v); },
+            (s) => { return (float)s.m_sculptLOD; },
+            (s,p,l,v) => { s.m_sculptLOD = (int)v; } ),
 
         new ParameterDefn("MaxSubStep", "In simulation step, maximum number of substeps",
             10f,
@@ -1042,16 +928,11 @@ public sealed class BSScene : PhysicsScene, IPhysicsParameters
             (s,cf,p,v) => { s.m_maxUpdatesPerFrame = cf.GetInt(p, (int)v); },
             (s) => { return (float)s.m_maxUpdatesPerFrame; },
             (s,p,l,v) => { s.m_maxUpdatesPerFrame = (int)v; } ),
-        new ParameterDefn("MaxTaintsToProcessPerStep", "Number of update taints to process before each simulation step",
-            100f,
-            (s,cf,p,v) => { s.m_taintsToProcessPerStep = cf.GetInt(p, (int)v); },
-            (s) => { return (float)s.m_taintsToProcessPerStep; },
-            (s,p,l,v) => { s.m_taintsToProcessPerStep = (int)v; } ),
         new ParameterDefn("MaxObjectMass", "Maximum object mass (10000.01)",
             10000.01f,
-            (s,cf,p,v) => { s.MaximumObjectMass = cf.GetFloat(p, v); },
-            (s) => { return (float)s.MaximumObjectMass; },
-            (s,p,l,v) => { s.MaximumObjectMass = v; } ),
+            (s,cf,p,v) => { s.m_maximumObjectMass = cf.GetFloat(p, v); },
+            (s) => { return (float)s.m_maximumObjectMass; },
+            (s,p,l,v) => { s.m_maximumObjectMass = v; } ),
 
         new ParameterDefn("PID_D", "Derivitive factor for motion smoothing",
             2200f,
@@ -1088,118 +969,104 @@ public sealed class BSScene : PhysicsScene, IPhysicsParameters
             -9.80665f,
             (s,cf,p,v) => { s.m_params[0].gravity = cf.GetFloat(p, v); },
             (s) => { return s.m_params[0].gravity; },
-            (s,p,l,v) => { s.UpdateParameterObject(ref s.m_params[0].gravity, p, PhysParameterEntry.APPLY_TO_NONE, v); },
-            (s,o,v) => { BulletSimAPI.SetGravity2(s.World.ptr, new Vector3(0f,0f,v)); } ),
+            (s,p,l,v) => { s.m_params[0].gravity = v; s.TaintedUpdateParameter(p,l,v); } ),
 
 
         new ParameterDefn("LinearDamping", "Factor to damp linear movement per second (0.0 - 1.0)",
             0f,
             (s,cf,p,v) => { s.m_params[0].linearDamping = cf.GetFloat(p, v); },
             (s) => { return s.m_params[0].linearDamping; },
-            (s,p,l,v) => { s.UpdateParameterObject(ref s.m_params[0].linearDamping, p, l, v); },
-            (s,o,v) => { BulletSimAPI.SetDamping2(o.PhysBody.ptr, v, v); } ),
+            (s,p,l,v) => { s.UpdateParameterPrims(ref s.m_params[0].linearDamping, p, l, v); } ),
         new ParameterDefn("AngularDamping", "Factor to damp angular movement per second (0.0 - 1.0)",
             0f,
             (s,cf,p,v) => { s.m_params[0].angularDamping = cf.GetFloat(p, v); },
             (s) => { return s.m_params[0].angularDamping; },
-            (s,p,l,v) => { s.UpdateParameterObject(ref s.m_params[0].angularDamping, p, l, v); },
-            (s,o,v) => { BulletSimAPI.SetDamping2(o.PhysBody.ptr, v, v); } ),
+            (s,p,l,v) => { s.UpdateParameterPrims(ref s.m_params[0].angularDamping, p, l, v); } ),
         new ParameterDefn("DeactivationTime", "Seconds before considering an object potentially static",
             0.2f,
             (s,cf,p,v) => { s.m_params[0].deactivationTime = cf.GetFloat(p, v); },
             (s) => { return s.m_params[0].deactivationTime; },
-            (s,p,l,v) => { s.UpdateParameterObject(ref s.m_params[0].deactivationTime, p, l, v); },
-            (s,o,v) => { BulletSimAPI.SetDeactivationTime2(o.PhysBody.ptr, v); } ),
+            (s,p,l,v) => { s.UpdateParameterPrims(ref s.m_params[0].deactivationTime, p, l, v); } ),
         new ParameterDefn("LinearSleepingThreshold", "Seconds to measure linear movement before considering static",
             0.8f,
             (s,cf,p,v) => { s.m_params[0].linearSleepingThreshold = cf.GetFloat(p, v); },
             (s) => { return s.m_params[0].linearSleepingThreshold; },
-            (s,p,l,v) => { s.UpdateParameterObject(ref s.m_params[0].linearSleepingThreshold, p, l, v); },
-            (s,o,v) => { BulletSimAPI.SetSleepingThresholds2(o.PhysBody.ptr, v, v); } ),
+            (s,p,l,v) => { s.UpdateParameterPrims(ref s.m_params[0].linearSleepingThreshold, p, l, v); } ),
         new ParameterDefn("AngularSleepingThreshold", "Seconds to measure angular movement before considering static",
             1.0f,
             (s,cf,p,v) => { s.m_params[0].angularSleepingThreshold = cf.GetFloat(p, v); },
             (s) => { return s.m_params[0].angularSleepingThreshold; },
-            (s,p,l,v) => { s.UpdateParameterObject(ref s.m_params[0].angularSleepingThreshold, p, l, v); },
-            (s,o,v) => { BulletSimAPI.SetSleepingThresholds2(o.PhysBody.ptr, v, v); } ),
+            (s,p,l,v) => { s.UpdateParameterPrims(ref s.m_params[0].angularSleepingThreshold, p, l, v); } ),
         new ParameterDefn("CcdMotionThreshold", "Continuious collision detection threshold (0 means no CCD)" ,
             0f,     // set to zero to disable
             (s,cf,p,v) => { s.m_params[0].ccdMotionThreshold = cf.GetFloat(p, v); },
             (s) => { return s.m_params[0].ccdMotionThreshold; },
-            (s,p,l,v) => { s.UpdateParameterObject(ref s.m_params[0].ccdMotionThreshold, p, l, v); },
-            (s,o,v) => { BulletSimAPI.SetCcdMotionThreshold2(o.PhysBody.ptr, v); } ),
+            (s,p,l,v) => { s.UpdateParameterPrims(ref s.m_params[0].ccdMotionThreshold, p, l, v); } ),
         new ParameterDefn("CcdSweptSphereRadius", "Continuious collision detection test radius" ,
             0f,
             (s,cf,p,v) => { s.m_params[0].ccdSweptSphereRadius = cf.GetFloat(p, v); },
             (s) => { return s.m_params[0].ccdSweptSphereRadius; },
-            (s,p,l,v) => { s.UpdateParameterObject(ref s.m_params[0].ccdSweptSphereRadius, p, l, v); },
-            (s,o,v) => { BulletSimAPI.SetCcdSweptSphereRadius2(o.PhysBody.ptr, v); } ),
+            (s,p,l,v) => { s.UpdateParameterPrims(ref s.m_params[0].ccdSweptSphereRadius, p, l, v); } ),
         new ParameterDefn("ContactProcessingThreshold", "Distance between contacts before doing collision check" ,
             0.1f,
             (s,cf,p,v) => { s.m_params[0].contactProcessingThreshold = cf.GetFloat(p, v); },
             (s) => { return s.m_params[0].contactProcessingThreshold; },
-            (s,p,l,v) => { s.UpdateParameterObject(ref s.m_params[0].contactProcessingThreshold, p, l, v); },
-            (s,o,v) => { BulletSimAPI.SetContactProcessingThreshold2(o.PhysBody.ptr, v); } ),
+            (s,p,l,v) => { s.UpdateParameterPrims(ref s.m_params[0].contactProcessingThreshold, p, l, v); } ),
 
         new ParameterDefn("TerrainFriction", "Factor to reduce movement against terrain surface" ,
             0.5f,
             (s,cf,p,v) => { s.m_params[0].terrainFriction = cf.GetFloat(p, v); },
             (s) => { return s.m_params[0].terrainFriction; },
-            (s,p,l,v) => { s.m_params[0].terrainFriction = v;  /* TODO: set on real terrain */} ),
+            (s,p,l,v) => { s.m_params[0].terrainFriction = v; s.TaintedUpdateParameter(p,l,v); } ),
         new ParameterDefn("TerrainHitFraction", "Distance to measure hit collisions" ,
             0.8f,
             (s,cf,p,v) => { s.m_params[0].terrainHitFraction = cf.GetFloat(p, v); },
             (s) => { return s.m_params[0].terrainHitFraction; },
-            (s,p,l,v) => { s.m_params[0].terrainHitFraction = v; /* TODO: set on real terrain */ } ),
+            (s,p,l,v) => { s.m_params[0].terrainHitFraction = v; s.TaintedUpdateParameter(p,l,v); } ),
         new ParameterDefn("TerrainRestitution", "Bouncyness" ,
             0f,
             (s,cf,p,v) => { s.m_params[0].terrainRestitution = cf.GetFloat(p, v); },
             (s) => { return s.m_params[0].terrainRestitution; },
-            (s,p,l,v) => { s.m_params[0].terrainRestitution = v;  /* TODO: set on real terrain */ } ),
+            (s,p,l,v) => { s.m_params[0].terrainRestitution = v; s.TaintedUpdateParameter(p,l,v); } ),
         new ParameterDefn("AvatarFriction", "Factor to reduce movement against an avatar. Changed on avatar recreation.",
-            0.2f,
+            0.5f,
             (s,cf,p,v) => { s.m_params[0].avatarFriction = cf.GetFloat(p, v); },
             (s) => { return s.m_params[0].avatarFriction; },
-            (s,p,l,v) => { s.UpdateParameterObject(ref s.m_params[0].avatarFriction, p, l, v); } ),
-        new ParameterDefn("AvatarStandingFriction", "Avatar friction when standing. Changed on avatar recreation.",
-            10f,
-            (s,cf,p,v) => { s.m_params[0].avatarStandingFriction = cf.GetFloat(p, v); },
-            (s) => { return s.m_params[0].avatarStandingFriction; },
-            (s,p,l,v) => { s.m_params[0].avatarStandingFriction = v; } ),
+            (s,p,l,v) => { s.UpdateParameterAvatars(ref s.m_params[0].avatarFriction, p, l, v); } ),
         new ParameterDefn("AvatarDensity", "Density of an avatar. Changed on avatar recreation.",
             60f,
             (s,cf,p,v) => { s.m_params[0].avatarDensity = cf.GetFloat(p, v); },
             (s) => { return s.m_params[0].avatarDensity; },
-            (s,p,l,v) => { s.UpdateParameterObject(ref s.m_params[0].avatarDensity, p, l, v); } ),
+            (s,p,l,v) => { s.UpdateParameterAvatars(ref s.m_params[0].avatarDensity, p, l, v); } ),
         new ParameterDefn("AvatarRestitution", "Bouncyness. Changed on avatar recreation.",
             0f,
             (s,cf,p,v) => { s.m_params[0].avatarRestitution = cf.GetFloat(p, v); },
             (s) => { return s.m_params[0].avatarRestitution; },
-            (s,p,l,v) => { s.UpdateParameterObject(ref s.m_params[0].avatarRestitution, p, l, v); } ),
+            (s,p,l,v) => { s.UpdateParameterAvatars(ref s.m_params[0].avatarRestitution, p, l, v); } ),
         new ParameterDefn("AvatarCapsuleRadius", "Radius of space around an avatar",
             0.37f,
             (s,cf,p,v) => { s.m_params[0].avatarCapsuleRadius = cf.GetFloat(p, v); },
             (s) => { return s.m_params[0].avatarCapsuleRadius; },
-            (s,p,l,v) => { s.UpdateParameterObject(ref s.m_params[0].avatarCapsuleRadius, p, l, v); } ),
+            (s,p,l,v) => { s.UpdateParameterAvatars(ref s.m_params[0].avatarCapsuleRadius, p, l, v); } ),
         new ParameterDefn("AvatarCapsuleHeight", "Default height of space around avatar",
             1.5f,
             (s,cf,p,v) => { s.m_params[0].avatarCapsuleHeight = cf.GetFloat(p, v); },
             (s) => { return s.m_params[0].avatarCapsuleHeight; },
-            (s,p,l,v) => { s.UpdateParameterObject(ref s.m_params[0].avatarCapsuleHeight, p, l, v); } ),
+            (s,p,l,v) => { s.UpdateParameterAvatars(ref s.m_params[0].avatarCapsuleHeight, p, l, v); } ),
             new ParameterDefn("AvatarContactProcessingThreshold", "Distance from capsule to check for collisions",
             0.1f,
             (s,cf,p,v) => { s.m_params[0].avatarContactProcessingThreshold = cf.GetFloat(p, v); },
             (s) => { return s.m_params[0].avatarContactProcessingThreshold; },
-            (s,p,l,v) => { s.UpdateParameterObject(ref s.m_params[0].avatarContactProcessingThreshold, p, l, v); } ),
+            (s,p,l,v) => { s.UpdateParameterAvatars(ref s.m_params[0].avatarContactProcessingThreshold, p, l, v); } ),
 
 
             new ParameterDefn("MaxPersistantManifoldPoolSize", "Number of manifolds pooled (0 means default of 4096)",
-            0f,
+            0f,     // zero to disable
             (s,cf,p,v) => { s.m_params[0].maxPersistantManifoldPoolSize = cf.GetFloat(p, v); },
             (s) => { return s.m_params[0].maxPersistantManifoldPoolSize; },
             (s,p,l,v) => { s.m_params[0].maxPersistantManifoldPoolSize = v; } ),
             new ParameterDefn("MaxCollisionAlgorithmPoolSize", "Number of collisions pooled (0 means default of 4096)",
-            0f,
+            0f,     // zero to disable
             (s,cf,p,v) => { s.m_params[0].maxCollisionAlgorithmPoolSize = cf.GetFloat(p, v); },
             (s) => { return s.m_params[0].maxCollisionAlgorithmPoolSize; },
             (s,p,l,v) => { s.m_params[0].maxCollisionAlgorithmPoolSize = v; } ),
@@ -1214,12 +1081,12 @@ public sealed class BSScene : PhysicsScene, IPhysicsParameters
             (s) => { return s.m_params[0].shouldForceUpdateAllAabbs; },
             (s,p,l,v) => { s.m_params[0].shouldForceUpdateAllAabbs = v; } ),
             new ParameterDefn("ShouldRandomizeSolverOrder", "Enable for slightly better stacking interaction",
-            ConfigurationParameters.numericTrue,
+            ConfigurationParameters.numericFalse,
             (s,cf,p,v) => { s.m_params[0].shouldRandomizeSolverOrder = s.NumericBool(cf.GetBoolean(p, s.BoolNumeric(v))); },
             (s) => { return s.m_params[0].shouldRandomizeSolverOrder; },
             (s,p,l,v) => { s.m_params[0].shouldRandomizeSolverOrder = v; } ),
             new ParameterDefn("ShouldSplitSimulationIslands", "Enable splitting active object scanning islands",
-            ConfigurationParameters.numericTrue,
+            ConfigurationParameters.numericFalse,
             (s,cf,p,v) => { s.m_params[0].shouldSplitSimulationIslands = s.NumericBool(cf.GetBoolean(p, s.BoolNumeric(v))); },
             (s) => { return s.m_params[0].shouldSplitSimulationIslands; },
             (s,p,l,v) => { s.m_params[0].shouldSplitSimulationIslands = v; } ),
@@ -1234,11 +1101,6 @@ public sealed class BSScene : PhysicsScene, IPhysicsParameters
             (s) => { return s.m_params[0].numberOfSolverIterations; },
             (s,p,l,v) => { s.m_params[0].numberOfSolverIterations = v; } ),
 
-            new ParameterDefn("LinksetImplementation", "Type of linkset implementation (0=Constraint, 1=Compound, 2=Manual)",
-            (float)BSLinkset.LinksetImplementation.Compound,
-            (s,cf,p,v) => { s.m_params[0].linksetImplementation = cf.GetFloat(p,v); },
-            (s) => { return s.m_params[0].linksetImplementation; },
-            (s,p,l,v) => { s.m_params[0].linksetImplementation = v; } ),
             new ParameterDefn("LinkConstraintUseFrameOffset", "For linksets built with constraints, enable frame offsetFor linksets built with constraints, enable frame offset.",
             ConfigurationParameters.numericFalse,
             (s,cf,p,v) => { s.m_params[0].linkConstraintUseFrameOffset = s.NumericBool(cf.GetBoolean(p, s.BoolNumeric(v))); },
@@ -1259,27 +1121,28 @@ public sealed class BSScene : PhysicsScene, IPhysicsParameters
             (s,cf,p,v) => { s.m_params[0].linkConstraintTransMotorMaxForce = cf.GetFloat(p, v); },
             (s) => { return s.m_params[0].linkConstraintTransMotorMaxForce; },
             (s,p,l,v) => { s.m_params[0].linkConstraintTransMotorMaxForce = v; } ),
-            new ParameterDefn("LinkConstraintCFM", "Amount constraint can be violated. 0=no violation, 1=infinite. Default=0.1",
-            0.1f,
+            new ParameterDefn("LinkConstraintCFM", "Amount constraint can be violated. 0=none, 1=all. Default=0",
+            0.0f,
             (s,cf,p,v) => { s.m_params[0].linkConstraintCFM = cf.GetFloat(p, v); },
             (s) => { return s.m_params[0].linkConstraintCFM; },
             (s,p,l,v) => { s.m_params[0].linkConstraintCFM = v; } ),
             new ParameterDefn("LinkConstraintERP", "Amount constraint is corrected each tick. 0=none, 1=all. Default = 0.2",
-            0.1f,
+            0.2f,
             (s,cf,p,v) => { s.m_params[0].linkConstraintERP = cf.GetFloat(p, v); },
             (s) => { return s.m_params[0].linkConstraintERP; },
             (s,p,l,v) => { s.m_params[0].linkConstraintERP = v; } ),
-            new ParameterDefn("LinkConstraintSolverIterations", "Number of solver iterations when computing constraint. (0 = Bullet default)",
-            40,
-            (s,cf,p,v) => { s.m_params[0].linkConstraintSolverIterations = cf.GetFloat(p, v); },
-            (s) => { return s.m_params[0].linkConstraintSolverIterations; },
-            (s,p,l,v) => { s.m_params[0].linkConstraintSolverIterations = v; } ),
 
-        new ParameterDefn("LogPhysicsStatisticsFrames", "Frames between outputting detailed phys stats. (0 is off)",
+        new ParameterDefn("DetailedStats", "Frames between outputting detailed phys stats. (0 is off)",
             0f,
-            (s,cf,p,v) => { s.m_params[0].physicsLoggingFrames = cf.GetInt(p, (int)v); },
-            (s) => { return (float)s.m_params[0].physicsLoggingFrames; },
-            (s,p,l,v) => { s.m_params[0].physicsLoggingFrames = (int)v; } ),
+            (s,cf,p,v) => { s.m_detailedStatsStep = cf.GetInt(p, (int)v); },
+            (s) => { return (float)s.m_detailedStatsStep; },
+            (s,p,l,v) => { s.m_detailedStatsStep = (int)v; } ),
+        new ParameterDefn("ShouldDebugLog", "Enables detailed DEBUG log statements",
+            ConfigurationParameters.numericFalse,
+            (s,cf,p,v) => { s.ShouldDebugLog = cf.GetBoolean(p, s.BoolNumeric(v)); },
+            (s) => { return s.NumericBool(s.ShouldDebugLog); },
+            (s,p,l,v) => { s.ShouldDebugLog = s.BoolNumeric(v); } ),
+
     };
 
     // Convert a boolean to our numeric true and false values
@@ -1337,12 +1200,11 @@ public sealed class BSScene : PhysicsScene, IPhysicsParameters
 
     private PhysParameterEntry[] SettableParameters = new PhysParameterEntry[1];
 
-    // This creates an array in the correct format for returning the list of
-    //    parameters. This is used by the 'list' option of the 'physics' command.
     private void BuildParameterTable()
     {
         if (SettableParameters.Length < ParameterDefinitions.Length)
         {
+
             List<PhysParameterEntry> entries = new List<PhysParameterEntry>();
             for (int ii = 0; ii < ParameterDefinitions.Length; ii++)
             {
@@ -1387,54 +1249,60 @@ public sealed class BSScene : PhysicsScene, IPhysicsParameters
         return ret;
     }
 
+    // check to see if we are updating a parameter for a particular or all of the prims
+    protected void UpdateParameterPrims(ref float loc, string parm, uint localID, float val)
+    {
+        List<uint> operateOn;
+        lock (m_prims) operateOn = new List<uint>(m_prims.Keys);
+        UpdateParameterSet(operateOn, ref loc, parm, localID, val);
+    }
+
+    // check to see if we are updating a parameter for a particular or all of the avatars
+    protected void UpdateParameterAvatars(ref float loc, string parm, uint localID, float val)
+    {
+        List<uint> operateOn;
+        lock (m_avatars) operateOn = new List<uint>(m_avatars.Keys);
+        UpdateParameterSet(operateOn, ref loc, parm, localID, val);
+    }
+
     // update all the localIDs specified
     // If the local ID is APPLY_TO_NONE, just change the default value
     // If the localID is APPLY_TO_ALL change the default value and apply the new value to all the lIDs
     // If the localID is a specific object, apply the parameter change to only that object
-    private void UpdateParameterObject(ref float defaultLoc, string parm, uint localID, float val)
+    protected void UpdateParameterSet(List<uint> lIDs, ref float defaultLoc, string parm, uint localID, float val)
     {
-        List<uint> objectIDs = new List<uint>();
         switch (localID)
         {
             case PhysParameterEntry.APPLY_TO_NONE:
                 defaultLoc = val;   // setting only the default value
-                // This will cause a call into the physical world if some operation is specified (SetOnObject).
-                objectIDs.Add(TERRAIN_ID);
-                TaintedUpdateParameter(parm, objectIDs, val);
                 break;
             case PhysParameterEntry.APPLY_TO_ALL:
                 defaultLoc = val;  // setting ALL also sets the default value
-                lock (PhysObjects) objectIDs = new List<uint>(PhysObjects.Keys);
-                TaintedUpdateParameter(parm, objectIDs, val);
+                List<uint> objectIDs = lIDs;
+                string xparm = parm.ToLower();
+                float xval = val;
+                TaintedObject("BSScene.UpdateParameterSet", delegate() {
+                    foreach (uint lID in objectIDs)
+                    {
+                        BulletSimAPI.UpdateParameter(m_worldID, lID, xparm, xval);
+                    }
+                });
                 break;
-            default:
+            default: 
                 // setting only one localID
-                objectIDs.Add(localID);
-                TaintedUpdateParameter(parm, objectIDs, val);
+                TaintedUpdateParameter(parm, localID, val);
                 break;
         }
     }
 
     // schedule the actual updating of the paramter to when the phys engine is not busy
-    private void TaintedUpdateParameter(string parm, List<uint> lIDs, float val)
+    protected void TaintedUpdateParameter(string parm, uint localID, float val)
     {
+        uint xlocalID = localID;
+        string xparm = parm.ToLower();
         float xval = val;
-        List<uint> xlIDs = lIDs;
-        string xparm = parm;
-        TaintedObject("BSScene.UpdateParameterSet", delegate() {
-            ParameterDefn thisParam;
-            if (TryGetParameter(xparm, out thisParam))
-            {
-                if (thisParam.onObject != null)
-                {
-                    foreach (uint lID in xlIDs)
-                    {
-                        BSPhysObject theObject = null;
-                        PhysObjects.TryGetValue(lID, out theObject);
-                        thisParam.onObject(this, theObject, xval);
-                    }
-                }
-            }
+        TaintedObject("BSScene.TaintedUpdateParameter", delegate() {
+            BulletSimAPI.UpdateParameter(m_worldID, xlocalID, xparm, xval);
         });
     }
 
@@ -1458,24 +1326,12 @@ public sealed class BSScene : PhysicsScene, IPhysicsParameters
 
     #endregion Runtime settable parameters
 
-    // Debugging routine for dumping detailed physical information for vehicle prims
-    private void DumpVehicles()
-    {
-        foreach (BSPrim prim in m_vehicles)
-        {
-            BulletSimAPI.DumpRigidBody2(World.ptr, prim.PhysBody.ptr);
-            BulletSimAPI.DumpCollisionShape2(World.ptr, prim.PhysShape.ptr);
-        }
-    }
-
     // Invoke the detailed logger and output something if it's enabled.
     public void DetailLog(string msg, params Object[] args)
     {
         PhysicsLogging.Write(msg, args);
-        // Add the Flush() if debugging crashes. Gets all the messages written out.
-        PhysicsLogging.Flush();
     }
-    // Used to fill in the LocalID when there isn't one. It's the correct number of characters.
+    // used to fill in the LocalID when there isn't one
     public const string DetailLogZero = "0000000000";
 
 }
diff --git a/OpenSim/Region/Physics/BulletSPlugin/BSShapeCollection.cs b/OpenSim/Region/Physics/BulletSPlugin/BSShapeCollection.cs
deleted file mode 100755
index 29a23c0..0000000
--- a/OpenSim/Region/Physics/BulletSPlugin/BSShapeCollection.cs
+++ /dev/null
@@ -1,1000 +0,0 @@
-/*
- * Copyright (c) Contributors, http://opensimulator.org/
- * See CONTRIBUTORS.TXT for a full list of copyright holders.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *     * Redistributions of source code must retain the above copyright
- *       notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyrightD
- *       notice, this list of conditions and the following disclaimer in the
- *       documentation and/or other materials provided with the distribution.
- *     * Neither the name of the OpenSimulator Project nor the
- *       names of its contributors may be used to endorse or promote products
- *       derived from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
- * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
- * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-using System;
-using System.Collections.Generic;
-using System.Text;
-using OMV = OpenMetaverse;
-using OpenSim.Framework;
-using OpenSim.Region.Physics.Manager;
-using OpenSim.Region.Physics.ConvexDecompositionDotNet;
-
-namespace OpenSim.Region.Physics.BulletSPlugin
-{
-public sealed class BSShapeCollection : IDisposable
-{
-    private static string LogHeader = "[BULLETSIM SHAPE COLLECTION]";
-
-    private BSScene PhysicsScene { get; set; }
-
-    private Object m_collectionActivityLock = new Object();
-
-    // Description of a Mesh
-    private struct MeshDesc
-    {
-        public IntPtr ptr;
-        public int referenceCount;
-        public DateTime lastReferenced;
-        public UInt64 shapeKey;
-    }
-
-    // Description of a hull.
-    // Meshes and hulls have the same shape hash key but we only need hulls for efficient collision calculations.
-    private struct HullDesc
-    {
-        public IntPtr ptr;
-        public int referenceCount;
-        public DateTime lastReferenced;
-        public UInt64 shapeKey;
-    }
-
-    // The sharable set of meshes and hulls. Indexed by their shape hash.
-    private Dictionary<System.UInt64, MeshDesc> Meshes = new Dictionary<System.UInt64, MeshDesc>();
-    private Dictionary<System.UInt64, HullDesc> Hulls = new Dictionary<System.UInt64, HullDesc>();
-
-    public BSShapeCollection(BSScene physScene)
-    {
-        PhysicsScene = physScene;
-    }
-
-    public void Dispose()
-    {
-        // TODO!!!!!!!!!
-    }
-
-    // Callbacks called just before either the body or shape is destroyed.
-    // Mostly used for changing bodies out from under Linksets.
-    // Useful for other cases where parameters need saving.
-    // Passing 'null' says no callback.
-    public delegate void ShapeDestructionCallback(BulletShape shape);
-    public delegate void BodyDestructionCallback(BulletBody body);
-
-    // Called to update/change the body and shape for an object.
-    // First checks the shape and updates that if necessary then makes
-    //    sure the body is of the right type.
-    // Return 'true' if either the body or the shape changed.
-    // 'shapeCallback' and 'bodyCallback' are, if non-null, functions called just before
-    //    the current shape or body is destroyed. This allows the caller to remove any
-    //    higher level dependencies on the shape or body. Mostly used for LinkSets to
-    //    remove the physical constraints before the body is destroyed.
-    // Called at taint-time!!
-    public bool GetBodyAndShape(bool forceRebuild, BulletSim sim, BSPhysObject prim,
-                    ShapeDestructionCallback shapeCallback, BodyDestructionCallback bodyCallback)
-    {
-        PhysicsScene.AssertInTaintTime("BSShapeCollection.GetBodyAndShape");
-
-        bool ret = false;
-
-        // This lock could probably be pushed down lower but building shouldn't take long
-        lock (m_collectionActivityLock)
-        {
-            // Do we have the correct geometry for this type of object?
-            // Updates prim.BSShape with information/pointers to shape.
-            // Returns 'true' of BSShape is changed to a new shape.
-            bool newGeom = CreateGeom(forceRebuild, prim, shapeCallback);
-            // If we had to select a new shape geometry for the object,
-            //    rebuild the body around it.
-            // Updates prim.BSBody with information/pointers to requested body
-            // Returns 'true' if BSBody was changed.
-            bool newBody = CreateBody((newGeom || forceRebuild), prim, PhysicsScene.World,
-                                    prim.PhysShape, bodyCallback);
-            ret = newGeom || newBody;
-        }
-        DetailLog("{0},BSShapeCollection.GetBodyAndShape,taintExit,force={1},ret={2},body={3},shape={4}",
-                                prim.LocalID, forceRebuild, ret, prim.PhysBody, prim.PhysShape);
-
-        return ret;
-    }
-
-    // Track another user of a body.
-    // We presume the caller has allocated the body.
-    // Bodies only have one user so the body is just put into the world if not already there.
-    public void ReferenceBody(BulletBody body, bool inTaintTime)
-    {
-        lock (m_collectionActivityLock)
-        {
-            DetailLog("{0},BSShapeCollection.ReferenceBody,newBody,body={1}", body.ID, body);
-            PhysicsScene.TaintedObject(inTaintTime, "BSShapeCollection.ReferenceBody", delegate()
-            {
-                if (!BulletSimAPI.IsInWorld2(body.ptr))
-                {
-                    BulletSimAPI.AddObjectToWorld2(PhysicsScene.World.ptr, body.ptr);
-                    DetailLog("{0},BSShapeCollection.ReferenceBody,addedToWorld,ref={1}", body.ID, body);
-                }
-            });
-        }
-    }
-
-    // Release the usage of a body.
-    // Called when releasing use of a BSBody. BSShape is handled separately.
-    public void DereferenceBody(BulletBody body, bool inTaintTime, BodyDestructionCallback bodyCallback )
-    {
-        if (body.ptr == IntPtr.Zero)
-            return;
-
-        lock (m_collectionActivityLock)
-        {
-            PhysicsScene.TaintedObject(inTaintTime, "BSShapeCollection.DereferenceBody", delegate()
-            {
-                DetailLog("{0},BSShapeCollection.DereferenceBody,DestroyingBody,body={1},inTaintTime={2}",
-                                            body.ID, body, inTaintTime);
-                // If the caller needs to know the old body is going away, pass the event up.
-                if (bodyCallback != null) bodyCallback(body);
-
-                if (BulletSimAPI.IsInWorld2(body.ptr))
-                {
-                    BulletSimAPI.RemoveObjectFromWorld2(PhysicsScene.World.ptr, body.ptr);
-                    DetailLog("{0},BSShapeCollection.DereferenceBody,removingFromWorld. Body={1}", body.ID, body);
-                }
-
-                // Zero any reference to the shape so it is not freed when the body is deleted.
-                BulletSimAPI.SetCollisionShape2(PhysicsScene.World.ptr, body.ptr, IntPtr.Zero);
-                BulletSimAPI.DestroyObject2(PhysicsScene.World.ptr, body.ptr);
-            });
-        }
-    }
-
-    // Track the datastructures and use count for a shape.
-    // When creating a hull, this is called first to reference the mesh
-    //     and then again to reference the hull.
-    // Meshes and hulls for the same shape have the same hash key.
-    // NOTE that native shapes are not added to the mesh list or removed.
-    // Returns 'true' if this is the initial reference to the shape. Otherwise reused.
-    public bool ReferenceShape(BulletShape shape)
-    {
-        bool ret = false;
-        switch (shape.type)
-        {
-            case ShapeData.PhysicsShapeType.SHAPE_MESH:
-                MeshDesc meshDesc;
-                if (Meshes.TryGetValue(shape.shapeKey, out meshDesc))
-                {
-                    // There is an existing instance of this mesh.
-                    meshDesc.referenceCount++;
-                    DetailLog("{0},BSShapeCollection.ReferenceShape,existingMesh,key={1},cnt={2}",
-                                BSScene.DetailLogZero, shape.shapeKey.ToString("X"), meshDesc.referenceCount);
-                }
-                else
-                {
-                    // This is a new reference to a mesh
-                    meshDesc.ptr = shape.ptr;
-                    meshDesc.shapeKey = shape.shapeKey;
-                    // We keep a reference to the underlying IMesh data so a hull can be built
-                    meshDesc.referenceCount = 1;
-                    DetailLog("{0},BSShapeCollection.ReferenceShape,newMesh,key={1},cnt={2}",
-                                BSScene.DetailLogZero, shape.shapeKey.ToString("X"), meshDesc.referenceCount);
-                    ret = true;
-                }
-                meshDesc.lastReferenced = System.DateTime.Now;
-                Meshes[shape.shapeKey] = meshDesc;
-                break;
-            case ShapeData.PhysicsShapeType.SHAPE_HULL:
-                HullDesc hullDesc;
-                if (Hulls.TryGetValue(shape.shapeKey, out hullDesc))
-                {
-                    // There is an existing instance of this hull.
-                    hullDesc.referenceCount++;
-                    DetailLog("{0},BSShapeCollection.ReferenceShape,existingHull,key={1},cnt={2}",
-                                BSScene.DetailLogZero, shape.shapeKey.ToString("X"), hullDesc.referenceCount);
-                }
-                else
-                {
-                    // This is a new reference to a hull
-                    hullDesc.ptr = shape.ptr;
-                    hullDesc.shapeKey = shape.shapeKey;
-                    hullDesc.referenceCount = 1;
-                    DetailLog("{0},BSShapeCollection.ReferenceShape,newHull,key={1},cnt={2}",
-                                BSScene.DetailLogZero, shape.shapeKey.ToString("X"), hullDesc.referenceCount);
-                    ret = true;
-
-                }
-                hullDesc.lastReferenced = System.DateTime.Now;
-                Hulls[shape.shapeKey] = hullDesc;
-                break;
-            case ShapeData.PhysicsShapeType.SHAPE_UNKNOWN:
-                break;
-            default:
-                // Native shapes are not tracked and they don't go into any list
-                break;
-        }
-        return ret;
-    }
-
-    // Release the usage of a shape.
-    public void DereferenceShape(BulletShape shape, bool inTaintTime, ShapeDestructionCallback shapeCallback)
-    {
-        if (shape.ptr == IntPtr.Zero)
-            return;
-
-        PhysicsScene.TaintedObject(inTaintTime, "BSShapeCollection.DereferenceShape", delegate()
-        {
-            if (shape.ptr != IntPtr.Zero)
-            {
-                if (shape.isNativeShape)
-                {
-                    // Native shapes are not tracked and are released immediately
-                    DetailLog("{0},BSShapeCollection.DereferenceShape,deleteNativeShape,ptr={1},taintTime={2}",
-                                    BSScene.DetailLogZero, shape.ptr.ToString("X"), inTaintTime);
-                    if (shapeCallback != null) shapeCallback(shape);
-                    BulletSimAPI.DeleteCollisionShape2(PhysicsScene.World.ptr, shape.ptr);
-                }
-                else
-                {
-                    switch (shape.type)
-                    {
-                        case ShapeData.PhysicsShapeType.SHAPE_HULL:
-                            DereferenceHull(shape, shapeCallback);
-                            break;
-                        case ShapeData.PhysicsShapeType.SHAPE_MESH:
-                            DereferenceMesh(shape, shapeCallback);
-                            break;
-                        case ShapeData.PhysicsShapeType.SHAPE_COMPOUND:
-                            DereferenceCompound(shape, shapeCallback);
-                            break;
-                        case ShapeData.PhysicsShapeType.SHAPE_UNKNOWN:
-                            break;
-                        default:
-                            break;
-                    }
-                }
-            }
-        });
-    }
-
-    // Count down the reference count for a mesh shape
-    // Called at taint-time.
-    private void DereferenceMesh(BulletShape shape, ShapeDestructionCallback shapeCallback)
-    {
-        MeshDesc meshDesc;
-        if (Meshes.TryGetValue(shape.shapeKey, out meshDesc))
-        {
-            meshDesc.referenceCount--;
-            // TODO: release the Bullet storage
-            if (shapeCallback != null) shapeCallback(shape);
-            meshDesc.lastReferenced = System.DateTime.Now;
-            Meshes[shape.shapeKey] = meshDesc;
-            DetailLog("{0},BSShapeCollection.DereferenceMesh,shape={1},refCnt={2}",
-                                BSScene.DetailLogZero, shape, meshDesc.referenceCount);
-
-        }
-    }
-
-    // Count down the reference count for a hull shape
-    // Called at taint-time.
-    private void DereferenceHull(BulletShape shape, ShapeDestructionCallback shapeCallback)
-    {
-        HullDesc hullDesc;
-        if (Hulls.TryGetValue(shape.shapeKey, out hullDesc))
-        {
-            hullDesc.referenceCount--;
-            // TODO: release the Bullet storage (aging old entries?)
-
-            // Tell upper layers that, if they have dependencies on this shape, this link is going away
-            if (shapeCallback != null) shapeCallback(shape);
-
-            hullDesc.lastReferenced = System.DateTime.Now;
-            Hulls[shape.shapeKey] = hullDesc;
-            DetailLog("{0},BSShapeCollection.DereferenceHull,shape={1},refCnt={2}",
-                    BSScene.DetailLogZero, shape, hullDesc.referenceCount);
-        }
-    }
-
-    // Remove a reference to a compound shape.
-    // Taking a compound shape apart is a little tricky because if you just delete the
-    //      physical shape, it will free all the underlying children. We can't do that because
-    //      they could be shared. So, this removes each of the children from the compound and
-    //      dereferences them separately before destroying the compound collision object itself.
-    // Called at taint-time.
-    private void DereferenceCompound(BulletShape shape, ShapeDestructionCallback shapeCallback)
-    {
-        if (!BulletSimAPI.IsCompound2(shape.ptr))
-        {
-            // Failed the sanity check!!
-            PhysicsScene.Logger.ErrorFormat("{0} Attempt to free a compound shape that is not compound!! type={1}, ptr={2}",
-                                        LogHeader, shape.type, shape.ptr.ToString("X"));
-            DetailLog("{0},BSShapeCollection.DereferenceCompound,notACompoundShape,type={1},ptr={2}",
-                                        BSScene.DetailLogZero, shape.type, shape.ptr.ToString("X"));
-            return;
-        }
-
-        int numChildren = BulletSimAPI.GetNumberOfCompoundChildren2(shape.ptr);
-        DetailLog("{0},BSShapeCollection.DereferenceCompound,shape={1},children={2}", BSScene.DetailLogZero, shape, numChildren);
-
-        for (int ii = numChildren - 1; ii >= 0; ii--)
-        {
-            IntPtr childShape = BulletSimAPI.RemoveChildShapeFromCompoundShapeIndex2(shape.ptr, ii);
-            DereferenceAnonCollisionShape(childShape);
-        }
-        BulletSimAPI.DeleteCollisionShape2(PhysicsScene.World.ptr, shape.ptr);
-    }
-
-    // Sometimes we have a pointer to a collision shape but don't know what type it is.
-    // Figure out type and call the correct dereference routine.
-    // Called at taint-time.
-    private void DereferenceAnonCollisionShape(IntPtr cShape)
-    {
-        MeshDesc meshDesc;
-        HullDesc hullDesc;
-
-        BulletShape shapeInfo = new BulletShape(cShape);
-        if (TryGetMeshByPtr(cShape, out meshDesc))
-        {
-            shapeInfo.type = ShapeData.PhysicsShapeType.SHAPE_MESH;
-            shapeInfo.shapeKey = meshDesc.shapeKey;
-        }
-        else
-        {
-            if (TryGetHullByPtr(cShape, out hullDesc))
-            {
-                shapeInfo.type = ShapeData.PhysicsShapeType.SHAPE_HULL;
-                shapeInfo.shapeKey = hullDesc.shapeKey;
-            }
-            else
-            {
-                if (BulletSimAPI.IsCompound2(cShape))
-                {
-                    shapeInfo.type = ShapeData.PhysicsShapeType.SHAPE_COMPOUND;
-                }
-                else
-                {
-                    if (BulletSimAPI.IsNativeShape2(cShape))
-                    {
-                        shapeInfo.isNativeShape = true;
-                        shapeInfo.type = ShapeData.PhysicsShapeType.SHAPE_BOX; // (technically, type doesn't matter)
-                    }
-                }
-            }
-        }
-
-        DetailLog("{0},BSShapeCollection.DereferenceAnonCollisionShape,shape={1}", BSScene.DetailLogZero, shapeInfo);
-
-        if (shapeInfo.type != ShapeData.PhysicsShapeType.SHAPE_UNKNOWN)
-        {
-            DereferenceShape(shapeInfo, true, null);
-        }
-        else
-        {
-            PhysicsScene.Logger.ErrorFormat("{0} Could not decypher shape type. Region={1}, addr={2}",
-                                    LogHeader, PhysicsScene.RegionName, cShape.ToString("X"));
-        }
-    }
-
-    // Create the geometry information in Bullet for later use.
-    // The objects needs a hull if it's physical otherwise a mesh is enough.
-    // if 'forceRebuild' is true, the geometry is unconditionally rebuilt. For meshes and hulls,
-    //     shared geometries will be used. If the parameters of the existing shape are the same
-    //     as this request, the shape is not rebuilt.
-    // Info in prim.BSShape is updated to the new shape.
-    // Returns 'true' if the geometry was rebuilt.
-    // Called at taint-time!
-    private bool CreateGeom(bool forceRebuild, BSPhysObject prim, ShapeDestructionCallback shapeCallback)
-    {
-        bool ret = false;
-        bool haveShape = false;
-
-        if (!haveShape && prim.PreferredPhysicalShape == ShapeData.PhysicsShapeType.SHAPE_AVATAR)
-        {
-            // an avatar capsule is close to a native shape (it is not shared)
-            ret = GetReferenceToNativeShape(prim, ShapeData.PhysicsShapeType.SHAPE_AVATAR,
-                            ShapeData.FixedShapeKey.KEY_CAPSULE, shapeCallback);
-            DetailLog("{0},BSShapeCollection.CreateGeom,avatarCapsule,shape={1}", prim.LocalID, prim.PhysShape);
-            ret = true;
-            haveShape = true;
-        }
-
-        // Compound shapes are handled special as they are rebuilt from scratch.
-        // This isn't too great a hardship since most of the child shapes will already been created.
-        if (!haveShape && prim.PreferredPhysicalShape == ShapeData.PhysicsShapeType.SHAPE_COMPOUND)
-        {
-            ret = GetReferenceToCompoundShape(prim, shapeCallback);
-            DetailLog("{0},BSShapeCollection.CreateGeom,compoundShape,shape={1}", prim.LocalID, prim.PhysShape);
-            haveShape = true;
-        }
-
-        if (!haveShape)
-        {
-            ret = CreateGeomNonSpecial(forceRebuild, prim, shapeCallback);
-        }
-
-        return ret;
-    }
-
-    // Create a mesh/hull shape or a native shape if 'nativeShapePossible' is 'true'.
-    private bool CreateGeomNonSpecial(bool forceRebuild, BSPhysObject prim, ShapeDestructionCallback shapeCallback)
-    {
-        bool ret = false;
-        bool haveShape = false;
-        bool nativeShapePossible = true;
-        PrimitiveBaseShape pbs = prim.BaseShape;
-
-        // If the prim attributes are simple, this could be a simple Bullet native shape
-        if (!haveShape
-                && pbs != null
-                && nativeShapePossible
-                && ((pbs.SculptEntry && !PhysicsScene.ShouldMeshSculptedPrim)
-                    || (pbs.ProfileBegin == 0 && pbs.ProfileEnd == 0
-                        && pbs.ProfileHollow == 0
-                        && pbs.PathTwist == 0 && pbs.PathTwistBegin == 0
-                        && pbs.PathBegin == 0 && pbs.PathEnd == 0
-                        && pbs.PathTaperX == 0 && pbs.PathTaperY == 0
-                        && pbs.PathScaleX == 100 && pbs.PathScaleY == 100
-                        && pbs.PathShearX == 0 && pbs.PathShearY == 0) ) )
-        {
-            // It doesn't look like Bullet scales spheres so make sure the scales are all equal
-            if ((pbs.ProfileShape == ProfileShape.HalfCircle && pbs.PathCurve == (byte)Extrusion.Curve1)
-                                && pbs.Scale.X == pbs.Scale.Y && pbs.Scale.Y == pbs.Scale.Z)
-            {
-                haveShape = true;
-                if (forceRebuild
-                        || prim.Scale != prim.Size
-                        || prim.PhysShape.type != ShapeData.PhysicsShapeType.SHAPE_SPHERE
-                        )
-                {
-                    ret = GetReferenceToNativeShape(prim, ShapeData.PhysicsShapeType.SHAPE_SPHERE,
-                                            ShapeData.FixedShapeKey.KEY_SPHERE, shapeCallback);
-                    DetailLog("{0},BSShapeCollection.CreateGeom,sphere,force={1},shape={2}",
-                                        prim.LocalID, forceRebuild, prim.PhysShape);
-                }
-            }
-            if (!haveShape && pbs.ProfileShape == ProfileShape.Square && pbs.PathCurve == (byte)Extrusion.Straight)
-            {
-                haveShape = true;
-                if (forceRebuild
-                        || prim.Scale != prim.Size
-                        || prim.PhysShape.type != ShapeData.PhysicsShapeType.SHAPE_BOX
-                        )
-                {
-                    ret = GetReferenceToNativeShape( prim, ShapeData.PhysicsShapeType.SHAPE_BOX,
-                                            ShapeData.FixedShapeKey.KEY_BOX, shapeCallback);
-                    DetailLog("{0},BSShapeCollection.CreateGeom,box,force={1},shape={2}",
-                                        prim.LocalID, forceRebuild, prim.PhysShape);
-                }
-            }
-        }
-
-        // If a simple shape is not happening, create a mesh and possibly a hull.
-        if (!haveShape && pbs != null)
-        {
-            ret = CreateGeomMeshOrHull(prim, shapeCallback);
-        }
-
-        return ret;
-    }
-
-    public bool CreateGeomMeshOrHull(BSPhysObject prim, ShapeDestructionCallback shapeCallback)
-    {
-
-        bool ret = false;
-        // Note that if it's a native shape, the check for physical/non-physical is not
-        //     made. Native shapes work in either case.
-        if (prim.IsPhysical && PhysicsScene.ShouldUseHullsForPhysicalObjects)
-        {
-            // Update prim.BSShape to reference a hull of this shape.
-            ret = GetReferenceToHull(prim,shapeCallback);
-            DetailLog("{0},BSShapeCollection.CreateGeom,hull,shape={1},key={2}",
-                                    prim.LocalID, prim.PhysShape, prim.PhysShape.shapeKey.ToString("X"));
-        }
-        else
-        {
-            ret = GetReferenceToMesh(prim, shapeCallback);
-            DetailLog("{0},BSShapeCollection.CreateGeom,mesh,shape={1},key={2}",
-                                    prim.LocalID, prim.PhysShape, prim.PhysShape.shapeKey.ToString("X"));
-        }
-        return ret;
-    }
-
-    // Creates a native shape and assignes it to prim.BSShape.
-    // "Native" shapes are never shared. they are created here and destroyed in DereferenceShape().
-    private bool GetReferenceToNativeShape(BSPhysObject prim,
-                            ShapeData.PhysicsShapeType shapeType, ShapeData.FixedShapeKey shapeKey,
-                            ShapeDestructionCallback shapeCallback)
-    {
-        // release any previous shape
-        DereferenceShape(prim.PhysShape, true, shapeCallback);
-
-        // Bullet native objects are scaled by the Bullet engine so pass the size in
-        prim.Scale = prim.Size;
-
-        BulletShape newShape = BuildPhysicalNativeShape(prim, shapeType, shapeKey);
-
-        // Don't need to do a 'ReferenceShape()' here because native shapes are not shared.
-        DetailLog("{0},BSShapeCollection.AddNativeShapeToPrim,create,newshape={1},scale={2}",
-                                prim.LocalID, newShape, prim.Scale);
-
-        prim.PhysShape = newShape;
-        return true;
-    }
-
-    private BulletShape BuildPhysicalNativeShape(BSPhysObject prim, ShapeData.PhysicsShapeType shapeType,
-                                    ShapeData.FixedShapeKey shapeKey)
-    {
-        BulletShape newShape;
-        // Need to make sure the passed shape information is for the native type.
-        ShapeData nativeShapeData = new ShapeData();
-        nativeShapeData.Type = shapeType;
-        nativeShapeData.ID = prim.LocalID;
-        nativeShapeData.Scale = prim.Scale;
-        nativeShapeData.Size = prim.Scale;
-        nativeShapeData.MeshKey = (ulong)shapeKey;
-        nativeShapeData.HullKey = (ulong)shapeKey;
-
-        if (shapeType == ShapeData.PhysicsShapeType.SHAPE_AVATAR)
-        {
-            newShape = new BulletShape(
-                        BulletSimAPI.BuildCapsuleShape2(PhysicsScene.World.ptr, 1f, 1f, prim.Scale)
-                        , shapeType);
-            DetailLog("{0},BSShapeCollection.BuiletPhysicalNativeShape,capsule,scale={1}", prim.LocalID, prim.Scale);
-        }
-        else
-        {
-            newShape = new BulletShape(BulletSimAPI.BuildNativeShape2(PhysicsScene.World.ptr, nativeShapeData), shapeType);
-        }
-        if (newShape.ptr == IntPtr.Zero)
-        {
-            PhysicsScene.Logger.ErrorFormat("{0} BuildPhysicalNativeShape failed. ID={1}, shape={2}",
-                                    LogHeader, prim.LocalID, shapeType);
-        }
-        newShape.shapeKey = (System.UInt64)shapeKey;
-        newShape.isNativeShape = true;
-
-        return newShape;
-    }
-
-    // Builds a mesh shape in the physical world and updates prim.BSShape.
-    // Dereferences previous shape in BSShape and adds a reference for this new shape.
-    // Returns 'true' of a mesh was actually built. Otherwise .
-    // Called at taint-time!
-    private bool GetReferenceToMesh(BSPhysObject prim, ShapeDestructionCallback shapeCallback)
-    {
-        BulletShape newShape = new BulletShape(IntPtr.Zero);
-
-        float lod;
-        System.UInt64 newMeshKey = ComputeShapeKey(prim.Size, prim.BaseShape, out lod);
-
-        // if this new shape is the same as last time, don't recreate the mesh
-        if (newMeshKey == prim.PhysShape.shapeKey && prim.PhysShape.type == ShapeData.PhysicsShapeType.SHAPE_MESH)
-            return false;
-
-        DetailLog("{0},BSShapeCollection.GetReferenceToMesh,create,oldKey={1},newKey={2}",
-                                prim.LocalID, prim.PhysShape.shapeKey.ToString("X"), newMeshKey.ToString("X"));
-
-        // Since we're recreating new, get rid of the reference to the previous shape
-        DereferenceShape(prim.PhysShape, true, shapeCallback);
-
-        newShape = CreatePhysicalMesh(prim.PhysObjectName, newMeshKey, prim.BaseShape, prim.Size, lod);
-        // Take evasive action if the mesh was not constructed.
-        newShape = VerifyMeshCreated(newShape, prim);
-
-        ReferenceShape(newShape);
-
-        // meshes are already scaled by the meshmerizer
-        prim.Scale = new OMV.Vector3(1f, 1f, 1f);
-        prim.PhysShape = newShape;
-
-        return true;        // 'true' means a new shape has been added to this prim
-    }
-
-    private BulletShape CreatePhysicalMesh(string objName, System.UInt64 newMeshKey, PrimitiveBaseShape pbs, OMV.Vector3 size, float lod)
-    {
-        IMesh meshData = null;
-        IntPtr meshPtr = IntPtr.Zero;
-        MeshDesc meshDesc;
-        if (Meshes.TryGetValue(newMeshKey, out meshDesc))
-        {
-            // If the mesh has already been built just use it.
-            meshPtr = meshDesc.ptr;
-        }
-        else
-        {
-            // Pass false for physicalness as this creates some sort of bounding box which we don't need
-            meshData = PhysicsScene.mesher.CreateMesh(objName, pbs, size, lod, false);
-
-            if (meshData != null)
-            {
-                int[] indices = meshData.getIndexListAsInt();
-                List<OMV.Vector3> vertices = meshData.getVertexList();
-
-                float[] verticesAsFloats = new float[vertices.Count * 3];
-                int vi = 0;
-                foreach (OMV.Vector3 vv in vertices)
-                {
-                    verticesAsFloats[vi++] = vv.X;
-                    verticesAsFloats[vi++] = vv.Y;
-                    verticesAsFloats[vi++] = vv.Z;
-                }
-
-                // m_log.DebugFormat("{0}: BSShapeCollection.CreatePhysicalMesh: calling CreateMesh. lid={1}, key={2}, indices={3}, vertices={4}",
-                //                  LogHeader, prim.LocalID, newMeshKey, indices.Length, vertices.Count);
-
-                meshPtr = BulletSimAPI.CreateMeshShape2(PhysicsScene.World.ptr,
-                                    indices.GetLength(0), indices, vertices.Count, verticesAsFloats);
-            }
-        }
-        BulletShape newShape = new BulletShape(meshPtr, ShapeData.PhysicsShapeType.SHAPE_MESH);
-        newShape.shapeKey = newMeshKey;
-
-        return newShape;
-    }
-
-    // See that hull shape exists in the physical world and update prim.BSShape.
-    // We could be creating the hull because scale changed or whatever.
-    private bool GetReferenceToHull(BSPhysObject prim, ShapeDestructionCallback shapeCallback)
-    {
-        BulletShape newShape;
-
-        float lod;
-        System.UInt64 newHullKey = ComputeShapeKey(prim.Size, prim.BaseShape, out lod);
-
-        // if the hull hasn't changed, don't rebuild it
-        if (newHullKey == prim.PhysShape.shapeKey && prim.PhysShape.type == ShapeData.PhysicsShapeType.SHAPE_HULL)
-            return false;
-
-        DetailLog("{0},BSShapeCollection.GetReferenceToHull,create,oldKey={1},newKey={2}",
-                        prim.LocalID, prim.PhysShape.shapeKey.ToString("X"), newHullKey.ToString("X"));
-
-        // Remove usage of the previous shape.
-        DereferenceShape(prim.PhysShape, true, shapeCallback);
-
-        newShape = CreatePhysicalHull(prim.PhysObjectName, newHullKey, prim.BaseShape, prim.Size, lod);
-        newShape = VerifyMeshCreated(newShape, prim);
-
-        ReferenceShape(newShape);
-
-        // hulls are already scaled by the meshmerizer
-        prim.Scale = new OMV.Vector3(1f, 1f, 1f);
-        prim.PhysShape = newShape;
-        return true;        // 'true' means a new shape has been added to this prim
-    }
-
-    List<ConvexResult> m_hulls;
-    private BulletShape CreatePhysicalHull(string objName, System.UInt64 newHullKey, PrimitiveBaseShape pbs, OMV.Vector3 size, float lod)
-    {
-
-        IntPtr hullPtr = IntPtr.Zero;
-        HullDesc hullDesc;
-        if (Hulls.TryGetValue(newHullKey, out hullDesc))
-        {
-            // If the hull shape already is created, just use it.
-            hullPtr = hullDesc.ptr;
-        }
-        else
-        {
-            // Build a new hull in the physical world
-            // Pass false for physicalness as this creates some sort of bounding box which we don't need
-            IMesh meshData = PhysicsScene.mesher.CreateMesh(objName, pbs, size, lod, false);
-            if (meshData != null)
-            {
-
-                int[] indices = meshData.getIndexListAsInt();
-                List<OMV.Vector3> vertices = meshData.getVertexList();
-
-                //format conversion from IMesh format to DecompDesc format
-                List<int> convIndices = new List<int>();
-                List<float3> convVertices = new List<float3>();
-                for (int ii = 0; ii < indices.GetLength(0); ii++)
-                {
-                    convIndices.Add(indices[ii]);
-                }
-                foreach (OMV.Vector3 vv in vertices)
-                {
-                    convVertices.Add(new float3(vv.X, vv.Y, vv.Z));
-                }
-
-                // setup and do convex hull conversion
-                m_hulls = new List<ConvexResult>();
-                DecompDesc dcomp = new DecompDesc();
-                dcomp.mIndices = convIndices;
-                dcomp.mVertices = convVertices;
-                ConvexBuilder convexBuilder = new ConvexBuilder(HullReturn);
-                // create the hull into the _hulls variable
-                convexBuilder.process(dcomp);
-
-                // Convert the vertices and indices for passing to unmanaged.
-                // The hull information is passed as a large floating point array.
-                // The format is:
-                //  convHulls[0] = number of hulls
-                //  convHulls[1] = number of vertices in first hull
-                //  convHulls[2] = hull centroid X coordinate
-                //  convHulls[3] = hull centroid Y coordinate
-                //  convHulls[4] = hull centroid Z coordinate
-                //  convHulls[5] = first hull vertex X
-                //  convHulls[6] = first hull vertex Y
-                //  convHulls[7] = first hull vertex Z
-                //  convHulls[8] = second hull vertex X
-                //  ...
-                //  convHulls[n] = number of vertices in second hull
-                //  convHulls[n+1] = second hull centroid X coordinate
-                //  ...
-                //
-                // TODO: is is very inefficient. Someday change the convex hull generator to return
-                //   data structures that do not need to be converted in order to pass to Bullet.
-                //   And maybe put the values directly into pinned memory rather than marshaling.
-                int hullCount = m_hulls.Count;
-                int totalVertices = 1;          // include one for the count of the hulls
-                foreach (ConvexResult cr in m_hulls)
-                {
-                    totalVertices += 4;                         // add four for the vertex count and centroid
-                    totalVertices += cr.HullIndices.Count * 3;  // we pass just triangles
-                }
-                float[] convHulls = new float[totalVertices];
-
-                convHulls[0] = (float)hullCount;
-                int jj = 1;
-                foreach (ConvexResult cr in m_hulls)
-                {
-                    // copy vertices for index access
-                    float3[] verts = new float3[cr.HullVertices.Count];
-                    int kk = 0;
-                    foreach (float3 ff in cr.HullVertices)
-                    {
-                        verts[kk++] = ff;
-                    }
-
-                    // add to the array one hull's worth of data
-                    convHulls[jj++] = cr.HullIndices.Count;
-                    convHulls[jj++] = 0f;   // centroid x,y,z
-                    convHulls[jj++] = 0f;
-                    convHulls[jj++] = 0f;
-                    foreach (int ind in cr.HullIndices)
-                    {
-                        convHulls[jj++] = verts[ind].x;
-                        convHulls[jj++] = verts[ind].y;
-                        convHulls[jj++] = verts[ind].z;
-                    }
-                }
-                // create the hull data structure in Bullet
-                hullPtr = BulletSimAPI.CreateHullShape2(PhysicsScene.World.ptr, hullCount, convHulls);
-            }
-        }
-
-        BulletShape newShape = new BulletShape(hullPtr, ShapeData.PhysicsShapeType.SHAPE_HULL);
-        newShape.shapeKey = newHullKey;
-
-        return newShape;        // 'true' means a new shape has been added to this prim
-    }
-
-    // Callback from convex hull creater with a newly created hull.
-    // Just add it to our collection of hulls for this shape.
-    private void HullReturn(ConvexResult result)
-    {
-        m_hulls.Add(result);
-        return;
-    }
-
-    // Compound shapes are always built from scratch.
-    // This shouldn't be to bad since most of the parts will be meshes that had been built previously.
-    private bool GetReferenceToCompoundShape(BSPhysObject prim, ShapeDestructionCallback shapeCallback)
-    {
-        // Remove reference to the old shape
-        // Don't need to do this as the shape is freed when the new root shape is created below.
-        // DereferenceShape(prim.PhysShape, true, shapeCallback);
-
-        BulletShape cShape = new BulletShape(
-            BulletSimAPI.CreateCompoundShape2(PhysicsScene.World.ptr, false), ShapeData.PhysicsShapeType.SHAPE_COMPOUND);
-
-        // Create the shape for the root prim and add it to the compound shape. Cannot be a native shape.
-        CreateGeomMeshOrHull(prim, shapeCallback);
-        BulletSimAPI.AddChildShapeToCompoundShape2(cShape.ptr, prim.PhysShape.ptr, OMV.Vector3.Zero, OMV.Quaternion.Identity);
-        DetailLog("{0},BSShapeCollection.GetReferenceToCompoundShape,addRootPrim,compShape={1},rootShape={2}",
-                                    prim.LocalID, cShape, prim.PhysShape);
-
-        prim.PhysShape = cShape;
-
-        return true;
-    }
-
-    // Create a hash of all the shape parameters to be used as a key
-    //    for this particular shape.
-    private System.UInt64 ComputeShapeKey(OMV.Vector3 size, PrimitiveBaseShape pbs, out float retLod)
-    {
-        // level of detail based on size and type of the object
-        float lod = PhysicsScene.MeshLOD;
-        if (pbs.SculptEntry)
-            lod = PhysicsScene.SculptLOD;
-
-        // Mega prims usually get more detail because one can interact with shape approximations at this size.
-        float maxAxis = Math.Max(size.X, Math.Max(size.Y, size.Z));
-        if (maxAxis > PhysicsScene.MeshMegaPrimThreshold)
-            lod = PhysicsScene.MeshMegaPrimLOD;
-
-        retLod = lod;
-        return pbs.GetMeshKey(size, lod);
-    }
-    // For those who don't want the LOD
-    private System.UInt64 ComputeShapeKey(OMV.Vector3 size, PrimitiveBaseShape pbs)
-    {
-        float lod;
-        return ComputeShapeKey(size, pbs, out lod);
-    }
-
-    // The creation of a mesh or hull can fail if an underlying asset is not available.
-    // There are two cases: 1) the asset is not in the cache and it needs to be fetched;
-    //     and 2) the asset cannot be converted (like failed decompression of JPEG2000s).
-    //     The first case causes the asset to be fetched. The second case requires
-    //     us to not loop forever.
-    // Called after creating a physical mesh or hull. If the physical shape was created,
-    //     just return.
-    private BulletShape VerifyMeshCreated(BulletShape newShape, BSPhysObject prim)
-    {
-        // If the shape was successfully created, nothing more to do
-        if (newShape.ptr != IntPtr.Zero)
-            return newShape;
-
-        // If this mesh has an underlying asset and we have not failed getting it before, fetch the asset
-        if (prim.BaseShape.SculptEntry && !prim.LastAssetBuildFailed && prim.BaseShape.SculptTexture != OMV.UUID.Zero)
-        {
-            prim.LastAssetBuildFailed = true;
-            BSPhysObject xprim = prim;
-            DetailLog("{0},BSShapeCollection.VerifyMeshCreated,fetchAsset,lID={1},lastFailed={2}",
-                            LogHeader, prim.LocalID, prim.LastAssetBuildFailed);
-            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)
-                        {
-                            if (!yprim.BaseShape.SculptEntry)
-                                return;
-                            if (yprim.BaseShape.SculptTexture.ToString() != asset.ID)
-                                return;
-
-                            yprim.BaseShape.SculptData = asset.Data;
-                            // This will cause the prim to see that the filler shape is not the right
-                            //    one and try again to build the object.
-                            // No race condition with the normal shape setting since the rebuild is at taint time.
-                            yprim.ForceBodyShapeRebuild(false);
-
-                        });
-                    }
-                });
-        }
-        else
-        {
-            if (prim.LastAssetBuildFailed)
-            {
-                PhysicsScene.Logger.ErrorFormat("{0} Mesh failed to fetch asset. lID={1}, texture={2}",
-                                            LogHeader, prim.LocalID, prim.BaseShape.SculptTexture);
-            }
-        }
-
-        // While we figure out the real problem, stick a simple native shape on the object.
-        BulletShape fillinShape =
-            BuildPhysicalNativeShape(prim, ShapeData.PhysicsShapeType.SHAPE_BOX, ShapeData.FixedShapeKey.KEY_BOX);
-
-        return fillinShape;
-    }
-
-    // Create a body object in Bullet.
-    // Updates prim.BSBody with the information about the new body if one is created.
-    // Returns 'true' if an object was actually created.
-    // Called at taint-time.
-    private bool CreateBody(bool forceRebuild, BSPhysObject prim, BulletSim sim, BulletShape shape,
-                            BodyDestructionCallback bodyCallback)
-    {
-        bool ret = false;
-
-        // the mesh, hull or native shape must have already been created in Bullet
-        bool mustRebuild = (prim.PhysBody.ptr == IntPtr.Zero);
-
-        // If there is an existing body, verify it's of an acceptable type.
-        // If not a solid object, body is a GhostObject. Otherwise a RigidBody.
-        if (!mustRebuild)
-        {
-            CollisionObjectTypes bodyType = (CollisionObjectTypes)BulletSimAPI.GetBodyType2(prim.PhysBody.ptr);
-            if (prim.IsSolid && bodyType != CollisionObjectTypes.CO_RIGID_BODY
-                || !prim.IsSolid && bodyType != CollisionObjectTypes.CO_GHOST_OBJECT)
-            {
-                // If the collisionObject is not the correct type for solidness, rebuild what's there
-                mustRebuild = true;
-            }
-        }
-
-        if (mustRebuild || forceRebuild)
-        {
-            // Free any old body
-            DereferenceBody(prim.PhysBody, true, bodyCallback);
-
-            BulletBody aBody;
-            IntPtr bodyPtr = IntPtr.Zero;
-            if (prim.IsSolid)
-            {
-                bodyPtr = BulletSimAPI.CreateBodyFromShape2(sim.ptr, shape.ptr,
-                                        prim.LocalID, prim.RawPosition, prim.RawOrientation);
-                DetailLog("{0},BSShapeCollection.CreateBody,mesh,ptr={1}", prim.LocalID, bodyPtr.ToString("X"));
-            }
-            else
-            {
-                bodyPtr = BulletSimAPI.CreateGhostFromShape2(sim.ptr, shape.ptr,
-                                        prim.LocalID, prim.ForcePosition, prim.ForceOrientation);
-                DetailLog("{0},BSShapeCollection.CreateBody,ghost,ptr={1}", prim.LocalID, bodyPtr.ToString("X"));
-            }
-            aBody = new BulletBody(prim.LocalID, bodyPtr);
-
-            ReferenceBody(aBody, true);
-
-            prim.PhysBody = aBody;
-
-            ret = true;
-        }
-
-        return ret;
-    }
-
-    private bool TryGetMeshByPtr(IntPtr addr, out MeshDesc outDesc)
-    {
-        bool ret = false;
-        MeshDesc foundDesc = new MeshDesc();
-        foreach (MeshDesc md in Meshes.Values)
-        {
-            if (md.ptr == addr)
-            {
-                foundDesc = md;
-                ret = true;
-                break;
-            }
-
-        }
-        outDesc = foundDesc;
-        return ret;
-    }
-
-    private bool TryGetHullByPtr(IntPtr addr, out HullDesc outDesc)
-    {
-        bool ret = false;
-        HullDesc foundDesc = new HullDesc();
-        foreach (HullDesc hd in Hulls.Values)
-        {
-            if (hd.ptr == addr)
-            {
-                foundDesc = hd;
-                ret = true;
-                break;
-            }
-
-        }
-        outDesc = foundDesc;
-        return ret;
-    }
-
-    private void DetailLog(string msg, params Object[] args)
-    {
-        if (PhysicsScene.PhysicsLogging.Enabled)
-            PhysicsScene.DetailLog(msg, args);
-    }
-}
-}
diff --git a/OpenSim/Region/Physics/BulletSPlugin/BSTerrainManager.cs b/OpenSim/Region/Physics/BulletSPlugin/BSTerrainManager.cs
deleted file mode 100755
index 7c34af2..0000000
--- a/OpenSim/Region/Physics/BulletSPlugin/BSTerrainManager.cs
+++ /dev/null
@@ -1,479 +0,0 @@
-/*
- * Copyright (c) Contributors, http://opensimulator.org/
- * See CONTRIBUTORS.TXT for a full list of copyright holders.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *     * Redistributions of source code must retain the above copyright
- *       notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyrightD
- *       notice, this list of conditions and the following disclaimer in the
- *       documentation and/or other materials provided with the distribution.
- *     * Neither the name of the OpenSimulator Project nor the
- *       names of its contributors may be used to endorse or promote products
- *       derived from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
- * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
- * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-using System;
-using System.Collections.Generic;
-using System.Text;
-
-using OpenSim.Framework;
-using OpenSim.Region.Framework;
-using OpenSim.Region.CoreModules;
-using OpenSim.Region.Physics.Manager;
-
-using Nini.Config;
-using log4net;
-
-using OpenMetaverse;
-
-namespace OpenSim.Region.Physics.BulletSPlugin
-{
-public sealed class BSTerrainManager
-{
-    static string LogHeader = "[BULLETSIM TERRAIN MANAGER]";
-
-    // These height values are fractional so the odd values will be
-    //     noticable when debugging.
-    public const float HEIGHT_INITIALIZATION = 24.987f;
-    public const float HEIGHT_INITIAL_LASTHEIGHT = 24.876f;
-    public const float HEIGHT_GETHEIGHT_RET = 24.765f;
-
-    // If the min and max height are equal, we reduce the min by this
-    //    amount to make sure that a bounding box is built for the terrain.
-    public const float HEIGHT_EQUAL_FUDGE = 0.2f;
-
-    public const float TERRAIN_COLLISION_MARGIN = 0.0f;
-
-    // Until the whole simulator is changed to pass us the region size, we rely on constants.
-    public Vector3 DefaultRegionSize = new Vector3(Constants.RegionSize, Constants.RegionSize, Constants.RegionHeight);
-
-    // The scene that I am part of
-    private BSScene PhysicsScene { get; set; }
-
-    // The ground plane created to keep thing from falling to infinity.
-    private BulletBody m_groundPlane;
-
-    // If doing mega-regions, if we're region zero we will be managing multiple
-    //    region terrains since region zero does the physics for the whole mega-region.
-    private Dictionary<Vector2, BulletHeightMapInfo> m_heightMaps;
-
-    // True of the terrain has been modified.
-    // Used to force recalculation of terrain height after terrain has been modified
-    private bool m_terrainModified;
-
-    // If we are doing mega-regions, terrains are added from TERRAIN_ID to m_terrainCount.
-    // This is incremented before assigning to new region so it is the last ID allocated.
-    private uint m_terrainCount = BSScene.CHILDTERRAIN_ID - 1;
-    public uint HighestTerrainID { get {return m_terrainCount; } }
-
-    // If doing mega-regions, this holds our offset from region zero of
-    //     the mega-regions. "parentScene" points to the PhysicsScene of region zero.
-    private Vector3 m_worldOffset;
-    // If the parent region (region 0), this is the extent of the combined regions
-    //     relative to the origin of region zero
-    private Vector3 m_worldMax;
-    private PhysicsScene MegaRegionParentPhysicsScene { get; set; }
-
-    public BSTerrainManager(BSScene physicsScene)
-    {
-        PhysicsScene = physicsScene;
-        m_heightMaps = new Dictionary<Vector2,BulletHeightMapInfo>();
-        m_terrainModified = false;
-
-        // Assume one region of default size
-        m_worldOffset = Vector3.Zero;
-        m_worldMax = new Vector3(DefaultRegionSize);
-        MegaRegionParentPhysicsScene = null;
-    }
-
-    // Create the initial instance of terrain and the underlying ground plane.
-    // The objects are allocated in the unmanaged space and the pointers are tracked
-    //    by the managed code.
-    // The terrains and the groundPlane are not added to the list of PhysObjects.
-    // This is called from the initialization routine so we presume it is
-    //    safe to call Bullet in real time. We hope no one is moving prims around yet.
-    public void CreateInitialGroundPlaneAndTerrain()
-    {
-        // The ground plane is here to catch things that are trying to drop to negative infinity
-        BulletShape groundPlaneShape = new BulletShape(
-                    BulletSimAPI.CreateGroundPlaneShape2(BSScene.GROUNDPLANE_ID, 1f, TERRAIN_COLLISION_MARGIN),
-                    ShapeData.PhysicsShapeType.SHAPE_GROUNDPLANE);
-        m_groundPlane = new BulletBody(BSScene.GROUNDPLANE_ID,
-                        BulletSimAPI.CreateBodyWithDefaultMotionState2(groundPlaneShape.ptr, BSScene.GROUNDPLANE_ID,
-                                                            Vector3.Zero, Quaternion.Identity));
-        BulletSimAPI.AddObjectToWorld2(PhysicsScene.World.ptr, m_groundPlane.ptr);
-        BulletSimAPI.UpdateSingleAabb2(PhysicsScene.World.ptr, m_groundPlane.ptr);
-        // Ground plane does not move
-        BulletSimAPI.ForceActivationState2(m_groundPlane.ptr, ActivationState.DISABLE_SIMULATION);
-        // Everything collides with the ground plane.
-        BulletSimAPI.SetCollisionFilterMask2(m_groundPlane.ptr,
-                        (uint)CollisionFilterGroups.GroundPlaneFilter, (uint)CollisionFilterGroups.GroundPlaneMask);
-
-        Vector3 minTerrainCoords = new Vector3(0f, 0f, HEIGHT_INITIALIZATION - HEIGHT_EQUAL_FUDGE);
-        Vector3 maxTerrainCoords = new Vector3(DefaultRegionSize.X, DefaultRegionSize.Y, HEIGHT_INITIALIZATION);
-        int totalHeights = (int)maxTerrainCoords.X * (int)maxTerrainCoords.Y;
-        float[] initialMap = new float[totalHeights];
-        for (int ii = 0; ii < totalHeights; ii++)
-        {
-            initialMap[ii] = HEIGHT_INITIALIZATION;
-        }
-        UpdateOrCreateTerrain(BSScene.TERRAIN_ID, initialMap, minTerrainCoords, maxTerrainCoords, true);
-    }
-
-    // Release all the terrain structures we might have allocated
-    public void ReleaseGroundPlaneAndTerrain()
-    {
-        if (m_groundPlane.ptr != IntPtr.Zero)
-        {
-            if (BulletSimAPI.RemoveObjectFromWorld2(PhysicsScene.World.ptr, m_groundPlane.ptr))
-            {
-                BulletSimAPI.DestroyObject2(PhysicsScene.World.ptr, m_groundPlane.ptr);
-            }
-            m_groundPlane.ptr = IntPtr.Zero;
-        }
-
-        ReleaseTerrain();
-    }
-
-    // Release all the terrain we have allocated
-    public void ReleaseTerrain()
-    {
-        foreach (KeyValuePair<Vector2, BulletHeightMapInfo> kvp in m_heightMaps)
-        {
-            if (BulletSimAPI.RemoveObjectFromWorld2(PhysicsScene.World.ptr, kvp.Value.terrainBody.ptr))
-            {
-                BulletSimAPI.DestroyObject2(PhysicsScene.World.ptr, kvp.Value.terrainBody.ptr);
-                BulletSimAPI.ReleaseHeightMapInfo2(kvp.Value.Ptr);
-            }
-        }
-        m_heightMaps.Clear();
-    }
-
-    // The simulator wants to set a new heightmap for the terrain.
-    public void SetTerrain(float[] heightMap) {
-        float[] localHeightMap = heightMap;
-        PhysicsScene.TaintedObject("TerrainManager.SetTerrain", delegate()
-        {
-            if (m_worldOffset != Vector3.Zero && MegaRegionParentPhysicsScene != null)
-            {
-                // If a child of a mega-region, we shouldn't have any terrain allocated for us
-                ReleaseGroundPlaneAndTerrain();
-                // If doing the mega-prim stuff and we are the child of the zero region,
-                //    the terrain is added to our parent
-                if (MegaRegionParentPhysicsScene is BSScene)
-                {
-                    DetailLog("{0},SetTerrain.ToParent,offset={1},worldMax={2}",
-                                    BSScene.DetailLogZero, m_worldOffset, m_worldMax);
-                    ((BSScene)MegaRegionParentPhysicsScene).TerrainManager.UpdateOrCreateTerrain(BSScene.CHILDTERRAIN_ID,
-                                    localHeightMap, m_worldOffset, m_worldOffset + DefaultRegionSize, true);
-                }
-            }
-            else
-            {
-                // If not doing the mega-prim thing, just change the terrain
-                DetailLog("{0},SetTerrain.Existing", BSScene.DetailLogZero);
-
-                UpdateOrCreateTerrain(BSScene.TERRAIN_ID, localHeightMap,
-                                    m_worldOffset, m_worldOffset + DefaultRegionSize, true);
-            }
-        });
-    }
-
-    // If called with no mapInfo for the terrain, this will create a new mapInfo and terrain
-    //     based on the passed information. The 'id' should be either the terrain id or
-    //     BSScene.CHILDTERRAIN_ID. If the latter, a new child terrain ID will be allocated and used.
-    //     The latter feature is for creating child terrains for mega-regions.
-    // If called with a mapInfo in m_heightMaps but the terrain has no body yet (mapInfo.terrainBody.Ptr == 0)
-    //     then a new body and shape is created and the mapInfo is filled.
-    //     This call is used for doing the initial terrain creation.
-    // If called with a mapInfo in m_heightMaps and there is an existing terrain body, a new
-    //     terrain shape is created and added to the body.
-    //     This call is most often used to update the heightMap and parameters of the terrain.
-    // (The above does suggest that some simplification/refactoring is in order.)
-    private void UpdateOrCreateTerrain(uint id, float[] heightMap, Vector3 minCoords, Vector3 maxCoords, bool inTaintTime)
-    {
-        DetailLog("{0},BSTerrainManager.UpdateOrCreateTerrain,call,minC={1},maxC={2},inTaintTime={3}",
-                            BSScene.DetailLogZero, minCoords, maxCoords, inTaintTime);
-
-        float minZ = float.MaxValue;
-        float maxZ = float.MinValue;
-        Vector2 terrainRegionBase = new Vector2(minCoords.X, minCoords.Y);
-
-        int heightMapSize = heightMap.Length;
-        for (int ii = 0; ii < heightMapSize; ii++)
-        {
-            float height = heightMap[ii];
-            if (height < minZ) minZ = height;
-            if (height > maxZ) maxZ = height;
-        }
-
-        // The shape of the terrain is from its base to its extents.
-        minCoords.Z = minZ;
-        maxCoords.Z = maxZ;
-
-        BulletHeightMapInfo mapInfo;
-        if (m_heightMaps.TryGetValue(terrainRegionBase, out mapInfo))
-        {
-            // If this is terrain we know about, it's easy to update
-
-            mapInfo.heightMap = heightMap;
-            mapInfo.minCoords = minCoords;
-            mapInfo.maxCoords = maxCoords;
-            mapInfo.minZ = minZ;
-            mapInfo.maxZ = maxZ;
-            mapInfo.sizeX = maxCoords.X - minCoords.X;
-            mapInfo.sizeY = maxCoords.Y - minCoords.Y;
-            DetailLog("{0},UpdateOrCreateTerrain:UpdateExisting,call,terrainBase={1},minC={2}, maxC={3}, szX={4}, szY={5}",
-                        BSScene.DetailLogZero, terrainRegionBase, mapInfo.minCoords, mapInfo.maxCoords, mapInfo.sizeX, mapInfo.sizeY);
-
-            PhysicsScene.TaintedObject(inTaintTime, "BSScene.UpdateOrCreateTerrain:UpdateExisting", delegate()
-            {
-                if (MegaRegionParentPhysicsScene != null)
-                {
-                    // It's possible that Combine() was called after this code was queued.
-                    // If we are a child of combined regions, we don't create any terrain for us.
-                    DetailLog("{0},UpdateOrCreateTerrain:AmACombineChild,taint", BSScene.DetailLogZero);
-
-                    // Get rid of any terrain that may have been allocated for us.
-                    ReleaseGroundPlaneAndTerrain();
-
-                    // I hate doing this, but just bail
-                    return;
-                }
-
-                if (mapInfo.terrainBody.ptr != IntPtr.Zero)
-                {
-                    // Updating an existing terrain.
-                    DetailLog("{0},UpdateOrCreateTerrain:UpdateExisting,taint,terrainBase={1},minC={2}, maxC={3}, szX={4}, szY={5}",
-                                    BSScene.DetailLogZero, terrainRegionBase, mapInfo.minCoords, mapInfo.maxCoords, mapInfo.sizeX, mapInfo.sizeY);
-
-                    // Remove from the dynamics world because we're going to mangle this object
-                    BulletSimAPI.RemoveObjectFromWorld2(PhysicsScene.World.ptr, mapInfo.terrainBody.ptr);
-
-                    // Get rid of the old terrain
-                    BulletSimAPI.DestroyObject2(PhysicsScene.World.ptr, mapInfo.terrainBody.ptr);
-                    BulletSimAPI.ReleaseHeightMapInfo2(mapInfo.Ptr);
-                    mapInfo.Ptr = IntPtr.Zero;
-
-                    /*
-                    // NOTE: This routine is half here because I can't get the terrain shape replacement
-                    //   to work. In the short term, the above three lines completely delete the old
-                    //   terrain and the code below recreates one from scratch.
-                    // Hopefully the Bullet community will help me out on this one.
-
-                    // First, release the old collision shape (there is only one terrain)
-                    BulletSimAPI.DeleteCollisionShape2(m_physicsScene.World.Ptr, mapInfo.terrainShape.Ptr);
-
-                    // Fill the existing height map info with the new location and size information
-                    BulletSimAPI.FillHeightMapInfo2(m_physicsScene.World.Ptr, mapInfo.Ptr, mapInfo.ID,
-                                    mapInfo.minCoords, mapInfo.maxCoords, mapInfo.heightMap, TERRAIN_COLLISION_MARGIN);
-
-                    // Create a terrain shape based on the new info
-                    mapInfo.terrainShape = new BulletShape(BulletSimAPI.CreateTerrainShape2(mapInfo.Ptr));
-
-                    // Stuff the shape into the existing terrain body
-                    BulletSimAPI.SetBodyShape2(m_physicsScene.World.Ptr, mapInfo.terrainBody.Ptr, mapInfo.terrainShape.Ptr);
-                    */
-                }
-                // else
-                {
-                    // Creating a new terrain.
-                    DetailLog("{0},UpdateOrCreateTerrain:CreateNewTerrain,taint,baseX={1},baseY={2},minZ={3},maxZ={4}",
-                                    BSScene.DetailLogZero, mapInfo.minCoords.X, mapInfo.minCoords.Y, minZ, maxZ);
-
-                    mapInfo.ID = id;
-                    mapInfo.Ptr = BulletSimAPI.CreateHeightMapInfo2(PhysicsScene.World.ptr, mapInfo.ID,
-                        mapInfo.minCoords, mapInfo.maxCoords, mapInfo.heightMap, TERRAIN_COLLISION_MARGIN);
-
-                    // Create the terrain shape from the mapInfo
-                    mapInfo.terrainShape = new BulletShape(BulletSimAPI.CreateTerrainShape2(mapInfo.Ptr),
-                                ShapeData.PhysicsShapeType.SHAPE_TERRAIN);
-
-                    // The terrain object initial position is at the center of the object
-                    Vector3 centerPos;
-                    centerPos.X = minCoords.X + (mapInfo.sizeX / 2f);
-                    centerPos.Y = minCoords.Y + (mapInfo.sizeY / 2f);
-                    centerPos.Z = minZ + ((maxZ - minZ) / 2f);
-
-                    mapInfo.terrainBody = new BulletBody(mapInfo.ID,
-                            BulletSimAPI.CreateBodyWithDefaultMotionState2(mapInfo.terrainShape.ptr,
-                                                        id, centerPos, Quaternion.Identity));
-                }
-
-                // Make sure the entry is in the heightmap table
-                m_heightMaps[terrainRegionBase] = mapInfo;
-
-                // Set current terrain attributes
-                BulletSimAPI.SetFriction2(mapInfo.terrainBody.ptr, PhysicsScene.Params.terrainFriction);
-                BulletSimAPI.SetHitFraction2(mapInfo.terrainBody.ptr, PhysicsScene.Params.terrainHitFraction);
-                BulletSimAPI.SetRestitution2(mapInfo.terrainBody.ptr, PhysicsScene.Params.terrainRestitution);
-                BulletSimAPI.SetCollisionFlags2(mapInfo.terrainBody.ptr, CollisionFlags.CF_STATIC_OBJECT);
-
-                // Return the new terrain to the world of physical objects
-                BulletSimAPI.AddObjectToWorld2(PhysicsScene.World.ptr, mapInfo.terrainBody.ptr);
-
-                // redo its bounding box now that it is in the world
-                BulletSimAPI.UpdateSingleAabb2(PhysicsScene.World.ptr, mapInfo.terrainBody.ptr);
-
-                BulletSimAPI.SetCollisionFilterMask2(mapInfo.terrainBody.ptr,
-                                    (uint)CollisionFilterGroups.TerrainFilter,
-                                    (uint)CollisionFilterGroups.TerrainMask);
-
-                // Make sure the new shape is processed.
-                // BulletSimAPI.Activate2(mapInfo.terrainBody.ptr, true);
-                // BulletSimAPI.ForceActivationState2(mapInfo.terrainBody.ptr, ActivationState.ISLAND_SLEEPING);
-                BulletSimAPI.ForceActivationState2(mapInfo.terrainBody.ptr, ActivationState.DISABLE_SIMULATION);
-
-                m_terrainModified = true;
-            });
-        }
-        else
-        {
-            // We don't know about this terrain so either we are creating a new terrain or
-            //    our mega-prim child is giving us a new terrain to add to the phys world
-
-            // if this is a child terrain, calculate a unique terrain id
-            uint newTerrainID = id;
-            if (newTerrainID >= BSScene.CHILDTERRAIN_ID)
-                newTerrainID = ++m_terrainCount;
-
-            float[] heightMapX = heightMap;
-            Vector3 minCoordsX = minCoords;
-            Vector3 maxCoordsX = maxCoords;
-
-            DetailLog("{0},UpdateOrCreateTerrain:NewTerrain,call,id={1}, minC={2}, maxC={3}",
-                            BSScene.DetailLogZero, newTerrainID, minCoords, minCoords);
-
-            // Code that must happen at taint-time
-            PhysicsScene.TaintedObject(inTaintTime, "BSScene.UpdateOrCreateTerrain:NewTerrain", delegate()
-            {
-                DetailLog("{0},UpdateOrCreateTerrain:NewTerrain,taint,baseX={1},baseY={2}", BSScene.DetailLogZero, minCoords.X, minCoords.Y);
-                // Create a new mapInfo that will be filled with the new info
-                mapInfo = new BulletHeightMapInfo(id, heightMapX,
-                        BulletSimAPI.CreateHeightMapInfo2(PhysicsScene.World.ptr, newTerrainID,
-                                    minCoordsX, maxCoordsX, heightMapX, TERRAIN_COLLISION_MARGIN));
-                // Put the unfilled heightmap info into the collection of same
-                m_heightMaps.Add(terrainRegionBase, mapInfo);
-                // Build the terrain
-                UpdateOrCreateTerrain(newTerrainID, heightMap, minCoords, maxCoords, true);
-
-                m_terrainModified = true;
-            });
-        }
-    }
-
-    // Someday we will have complex terrain with caves and tunnels
-    public float GetTerrainHeightAtXYZ(Vector3 loc)
-    {
-        // For the moment, it's flat and convex
-        return GetTerrainHeightAtXY(loc.X, loc.Y);
-    }
-
-    // Given an X and Y, find the height of the terrain.
-    // Since we could be handling multiple terrains for a mega-region,
-    //    the base of the region is calcuated assuming all regions are
-    //    the same size and that is the default.
-    // Once the heightMapInfo is found, we have all the information to
-    //    compute the offset into the array.
-    private float lastHeightTX = 999999f;
-    private float lastHeightTY = 999999f;
-    private float lastHeight = HEIGHT_INITIAL_LASTHEIGHT;
-    private float GetTerrainHeightAtXY(float tX, float tY)
-    {
-        // You'd be surprized at the number of times this routine is called
-        //    with the same parameters as last time.
-        if (!m_terrainModified && lastHeightTX == tX && lastHeightTY == tY)
-            return lastHeight;
-
-        lastHeightTX = tX;
-        lastHeightTY = tY;
-        float ret = HEIGHT_GETHEIGHT_RET;
-
-        int offsetX = ((int)(tX / (int)DefaultRegionSize.X)) * (int)DefaultRegionSize.X;
-        int offsetY = ((int)(tY / (int)DefaultRegionSize.Y)) * (int)DefaultRegionSize.Y;
-        Vector2 terrainBaseXY = new Vector2(offsetX, offsetY);
-
-        BulletHeightMapInfo mapInfo;
-        if (m_heightMaps.TryGetValue(terrainBaseXY, out mapInfo))
-        {
-            float regionX = tX - offsetX;
-            float regionY = tY - offsetY;
-            int mapIndex = (int)regionY * (int)mapInfo.sizeY + (int)regionX;
-            try
-            {
-                ret = mapInfo.heightMap[mapIndex];
-            }
-            catch
-            {
-                // Sometimes they give us wonky values of X and Y. Give a warning and return something.
-                PhysicsScene.Logger.WarnFormat("{0} Bad request for terrain height. terrainBase={1}, x={2}, y={3}",
-                                    LogHeader, terrainBaseXY, regionX, regionY);
-                ret = HEIGHT_GETHEIGHT_RET;
-            }
-            // DetailLog("{0},BSTerrainManager.GetTerrainHeightAtXY,bX={1},baseY={2},szX={3},szY={4},regX={5},regY={6},index={7},ht={8}",
-            //         BSScene.DetailLogZero, offsetX, offsetY, mapInfo.sizeX, mapInfo.sizeY, regionX, regionY, mapIndex, ret);
-        }
-        else
-        {
-            PhysicsScene.Logger.ErrorFormat("{0} GetTerrainHeightAtXY: terrain not found: region={1}, x={2}, y={3}",
-                    LogHeader, PhysicsScene.RegionName, tX, tY);
-        }
-        m_terrainModified = false;
-        lastHeight = ret;
-        return ret;
-    }
-
-    // Although no one seems to check this, I do support combining.
-    public bool SupportsCombining()
-    {
-        return true;
-    }
-
-    // This routine is called two ways:
-    //    One with 'offset' and 'pScene' zero and null but 'extents' giving the maximum
-    //        extent of the combined regions. This is to inform the parent of the size
-    //        of the combined regions.
-    //    and one with 'offset' as the offset of the child region to the base region,
-    //        'pScene' pointing to the parent and 'extents' of zero. This informs the
-    //        child of its relative base and new parent.
-    public void Combine(PhysicsScene pScene, Vector3 offset, Vector3 extents)
-    {
-        m_worldOffset = offset;
-        m_worldMax = extents;
-        MegaRegionParentPhysicsScene = pScene;
-        if (pScene != null)
-        {
-            // We are a child.
-            // We want m_worldMax to be the highest coordinate of our piece of terrain.
-            m_worldMax = offset + DefaultRegionSize;
-        }
-        DetailLog("{0},BSTerrainManager.Combine,offset={1},extents={2},wOffset={3},wMax={4}",
-                        BSScene.DetailLogZero, offset, extents, m_worldOffset, m_worldMax);
-    }
-
-    // Unhook all the combining that I know about.
-    public void UnCombine(PhysicsScene pScene)
-    {
-        // Just like ODE, for the moment a NOP
-        DetailLog("{0},BSTerrainManager.UnCombine", BSScene.DetailLogZero);
-    }
-
-
-    private void DetailLog(string msg, params Object[] args)
-    {
-        PhysicsScene.PhysicsLogging.Write(msg, args);
-    }
-}
-}
diff --git a/OpenSim/Region/Physics/BulletSPlugin/BulletSimAPI.cs b/OpenSim/Region/Physics/BulletSPlugin/BulletSimAPI.cs
index 702bd77..504bd3c 100644
--- a/OpenSim/Region/Physics/BulletSPlugin/BulletSimAPI.cs
+++ b/OpenSim/Region/Physics/BulletSPlugin/BulletSimAPI.cs
@@ -33,153 +33,38 @@ using OpenMetaverse;
 namespace OpenSim.Region.Physics.BulletSPlugin {
 
 // Classes to allow some type checking for the API
-// These hold pointers to allocated objects in the unmanaged space.
-
-// The physics engine controller class created at initialization
 public struct BulletSim
 {
-    public BulletSim(uint worldId, BSScene bss, IntPtr xx)
-    {
-        ptr = xx;
-        worldID = worldId;
-        physicsScene = bss;
-    }
-    public IntPtr ptr;
-    public uint worldID;
+    public BulletSim(uint id, BSScene bss, IntPtr xx) { ID = id; scene = bss;  Ptr = xx; }
+    public uint ID;
     // The scene is only in here so very low level routines have a handle to print debug/error messages
-    public BSScene physicsScene;
+    public BSScene scene;
+    public IntPtr Ptr;
 }
 
-// An allocated Bullet btRigidBody
 public struct BulletBody
 {
-    public BulletBody(uint id, IntPtr xx)
-    {
-        ID = id;
-        ptr = xx;
-        collisionFilter = 0;
-        collisionMask = 0;
-    }
-    public IntPtr ptr;
+    public BulletBody(uint id, IntPtr xx) { ID = id;  Ptr = xx; }
+    public IntPtr Ptr;
     public uint ID;
-    public CollisionFilterGroups collisionFilter;
-    public CollisionFilterGroups collisionMask;
-    public override string ToString()
-    {
-        StringBuilder buff = new StringBuilder();
-        buff.Append("<id=");
-        buff.Append(ID.ToString());
-        buff.Append(",p=");
-        buff.Append(ptr.ToString("X"));
-        if (collisionFilter != 0 || collisionMask != 0)
-        {
-            buff.Append(",f=");
-            buff.Append(collisionFilter.ToString("X"));
-            buff.Append(",m=");
-            buff.Append(collisionMask.ToString("X"));
-        }
-        buff.Append(">");
-        return buff.ToString();
-    }
-}
-
-public struct BulletShape
-{
-    public BulletShape(IntPtr xx)
-    {
-        ptr = xx;
-        type=ShapeData.PhysicsShapeType.SHAPE_UNKNOWN;
-        shapeKey = 0;
-        isNativeShape = false;
-    }
-    public BulletShape(IntPtr xx, ShapeData.PhysicsShapeType typ)
-    {
-        ptr = xx;
-        type = typ;
-        shapeKey = 0;
-        isNativeShape = false;
-    }
-    public IntPtr ptr;
-    public ShapeData.PhysicsShapeType type;
-    public System.UInt64 shapeKey;
-    public bool isNativeShape;
-    public override string ToString()
-    {
-        StringBuilder buff = new StringBuilder();
-        buff.Append("<p=");
-        buff.Append(ptr.ToString("X"));
-        buff.Append(",s=");
-        buff.Append(type.ToString());
-        buff.Append(",k=");
-        buff.Append(shapeKey.ToString("X"));
-        buff.Append(",n=");
-        buff.Append(isNativeShape.ToString());
-        buff.Append(">");
-        return buff.ToString();
-    }
 }
 
-    // Constraint type values as defined by Bullet
-public enum ConstraintType : int
-{
-        POINT2POINT_CONSTRAINT_TYPE = 3,
-        HINGE_CONSTRAINT_TYPE,
-        CONETWIST_CONSTRAINT_TYPE,
-        D6_CONSTRAINT_TYPE,
-        SLIDER_CONSTRAINT_TYPE,
-        CONTACT_CONSTRAINT_TYPE,
-        D6_SPRING_CONSTRAINT_TYPE,
-        MAX_CONSTRAINT_TYPE
-}
-
-// An allocated Bullet btConstraint
 public struct BulletConstraint
 {
-    public BulletConstraint(IntPtr xx)
-    {
-        ptr = xx;
-    }
-    public IntPtr ptr;
-}
-
-// An allocated HeightMapThing which holds various heightmap info.
-// Made a class rather than a struct so there would be only one
-//      instance of this and C# will pass around pointers rather
-//      than making copies.
-public class BulletHeightMapInfo
-{
-    public BulletHeightMapInfo(uint id, float[] hm, IntPtr xx) {
-        ID = id;
-        Ptr = xx;
-        heightMap = hm;
-        terrainRegionBase = new Vector2(0f, 0f);
-        minCoords = new Vector3(100f, 100f, 25f);
-        maxCoords = new Vector3(101f, 101f, 26f);
-        minZ = maxZ = 0f;
-        sizeX = sizeY = 256f;
-    }
-    public uint ID;
+    public BulletConstraint(IntPtr xx) { Ptr = xx; }
     public IntPtr Ptr;
-    public float[] heightMap;
-    public Vector2 terrainRegionBase;
-    public Vector3 minCoords;
-    public Vector3 maxCoords;
-    public float sizeX, sizeY;
-    public float minZ, maxZ;
-    public BulletShape terrainShape;
-    public BulletBody terrainBody;
 }
 
 // ===============================================================================
 [StructLayout(LayoutKind.Sequential)]
-public struct ConvexHull
+public struct ConvexHull 
 {
         Vector3 Offset;
         int VertexCount;
         Vector3[] Vertices;
 }
 [StructLayout(LayoutKind.Sequential)]
-public struct ShapeData
+public struct ShapeData 
 {
     public enum PhysicsShapeType
     {
@@ -190,11 +75,7 @@ public struct ShapeData
                 SHAPE_CYLINDER  = 4,
                 SHAPE_SPHERE    = 5,
                 SHAPE_MESH      = 6,
-                SHAPE_HULL      = 7,
-        // following defined by BulletSim
-                SHAPE_GROUNDPLANE  = 20,
-                SHAPE_TERRAIN   = 21,
-                SHAPE_COMPOUND  = 22,
+                SHAPE_HULL      = 7
     };
     public uint ID;
     public PhysicsShapeType Type;
@@ -210,25 +91,13 @@ public struct ShapeData
     public float Restitution;
     public float Collidable;    // true of things bump into this
     public float Static;        // true if a static object. Otherwise gravity, etc.
-    public float Solid;         // true if object cannot be passed through
-    public Vector3 Size;
 
     // note that bools are passed as floats since bool size changes by language and architecture
     public const float numericTrue = 1f;
     public const float numericFalse = 0f;
-
-    // The native shapes have predefined shape hash keys
-    public enum FixedShapeKey : ulong
-    {
-        KEY_BOX         = 1,
-        KEY_SPHERE      = 2,
-        KEY_CONE        = 3,
-        KEY_CYLINDER    = 4,
-        KEY_CAPSULE     = 5,
-    }
 }
 [StructLayout(LayoutKind.Sequential)]
-public struct SweepHit
+public struct SweepHit 
 {
     public uint ID;
     public float Fraction;
@@ -284,7 +153,6 @@ public struct ConfigurationParameters
     public float terrainHitFraction;
     public float terrainRestitution;
     public float avatarFriction;
-    public float avatarStandingFriction;
     public float avatarDensity;
     public float avatarRestitution;
     public float avatarCapsuleRadius;
@@ -300,45 +168,18 @@ public struct ConfigurationParameters
         public float shouldEnableFrictionCaching;
         public float numberOfSolverIterations;
 
-    public float linksetImplementation;
     public float linkConstraintUseFrameOffset;
     public float linkConstraintEnableTransMotor;
     public float linkConstraintTransMotorMaxVel;
     public float linkConstraintTransMotorMaxForce;
     public float linkConstraintERP;
     public float linkConstraintCFM;
-    public float linkConstraintSolverIterations;
-
-    public float physicsLoggingFrames;
 
     public const float numericTrue = 1f;
     public const float numericFalse = 0f;
 }
 
-
-// The states a bullet collision object can have
-public enum ActivationState : uint
-{
-    ACTIVE_TAG = 1,
-    ISLAND_SLEEPING,
-    WANTS_DEACTIVATION,
-    DISABLE_DEACTIVATION,
-    DISABLE_SIMULATION,
-}
-
-public enum CollisionObjectTypes : int
-{
-    CO_COLLISION_OBJECT             = 1 << 0,
-    CO_RIGID_BODY                   = 1 << 1,
-    CO_GHOST_OBJECT                 = 1 << 2,
-    CO_SOFT_BODY                    = 1 << 3,
-    CO_HF_FLUID                     = 1 << 4,
-    CO_USER_TYPE                    = 1 << 5,
-}
-
-// Values used by Bullet and BulletSim to control object properties.
-// Bullet's "CollisionFlags" has more to do with operations on the
-//    object (if collisions happen, if gravity effects it, ...).
+// Values used by Bullet and BulletSim to control collisions
 public enum CollisionFlags : uint
 {
     CF_STATIC_OBJECT                 = 1 << 0,
@@ -350,54 +191,9 @@ public enum CollisionFlags : uint
     CF_DISABLE_SPU_COLLISION_PROCESS = 1 << 6,
     // Following used by BulletSim to control collisions
     BS_SUBSCRIBE_COLLISION_EVENTS    = 1 << 10,
-    BS_FLOATS_ON_WATER               = 1 << 11,
-    BS_NONE                          = 0,
-    BS_ALL                           = 0xFFFFFFFF,
-
-    // These are the collision flags switched depending on physical state.
-    // The other flags are used for other things and should not be fooled with.
-    BS_ACTIVE = CF_STATIC_OBJECT
-                | CF_KINEMATIC_OBJECT
-                | CF_NO_CONTACT_RESPONSE
-};
-
-// Values for collisions groups and masks
-public enum CollisionFilterGroups : uint
-{
-    // Don't use the bit definitions!!  Define the use in a
-    //   filter/mask definition below. This way collision interactions
-    //   are more easily debugged.
-    BNoneFilter              = 0,
-    BDefaultFilter           = 1 << 0,
-    BStaticFilter            = 1 << 1,
-    BKinematicFilter         = 1 << 2,
-    BDebrisFilter            = 1 << 3,
-    BSensorTrigger           = 1 << 4,
-    BCharacterFilter         = 1 << 5,
-    BAllFilter               = 0xFFFFFFFF,
-    // Filter groups defined by BulletSim
-    BGroundPlaneFilter       = 1 << 10,
-    BTerrainFilter           = 1 << 11,
-    BRaycastFilter           = 1 << 12,
-    BSolidFilter             = 1 << 13,
-    BLinksetFilter           = 1 << 14,
-
-    // The collsion filters and masked are defined in one place -- don't want them scattered
-    AvatarFilter            = BCharacterFilter,
-    AvatarMask              = BAllFilter,
-    ObjectFilter            = BSolidFilter,
-    ObjectMask              = BAllFilter,
-    StaticObjectFilter      = BStaticFilter,
-    StaticObjectMask        = BAllFilter,
-    LinksetFilter           = BLinksetFilter,
-    LinksetMask             = BAllFilter & ~BLinksetFilter,
-    VolumeDetectFilter      = BSensorTrigger,
-    VolumeDetectMask        = ~BSensorTrigger,
-    TerrainFilter           = BTerrainFilter,
-    TerrainMask             = BAllFilter & ~BStaticFilter,
-    GroundPlaneFilter       = BGroundPlaneFilter,
-    GroundPlaneMask         = BAllFilter
-
+    BS_VOLUME_DETECT_OBJECT          = 1 << 11,
+    BS_PHANTOM_OBJECT                = 1 << 12,
+    BS_PHYSICAL_OBJECT               = 1 << 13,
 };
 
 // CFM controls the 'hardness' of the constraint. 0=fixed, 0..1=violatable. Default=0
@@ -425,23 +221,14 @@ public enum ConstraintParamAxis : int
 // ===============================================================================
 static class BulletSimAPI {
 
-// Link back to the managed code for outputting log messages
-[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
-public delegate void DebugLogCallback([MarshalAs(UnmanagedType.LPStr)]string msg);
-
 [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
 [return: MarshalAs(UnmanagedType.LPStr)]
 public static extern string GetVersion();
 
-/* Remove the linkage to the old api methods
 [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
-public static extern uint Initialize(Vector3 maxPosition, IntPtr parms,
-                        int maxCollisions, IntPtr collisionArray,
-                        int maxUpdates, IntPtr updateArray,
-                        DebugLogCallback logRoutine);
-
-[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
-public static extern void CreateInitialGroundPlaneAndTerrain(uint worldID);
+public static extern uint Initialize(Vector3 maxPosition, IntPtr parms, 
+                        int maxCollisions, IntPtr collisionArray, 
+                        int maxUpdates, IntPtr updateArray);
 
 [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
 public static extern void SetHeightmap(uint worldID, [MarshalAs(UnmanagedType.LPArray)] float[] heightMap);
@@ -455,19 +242,19 @@ public static extern bool UpdateParameter(uint worldID, uint localID,
 
 // ===============================================================================
 [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
-public static extern int PhysicsStep(uint worldID, float timeStep, int maxSubSteps, float fixedTimeStep,
-                        out int updatedEntityCount,
+public static extern int PhysicsStep(uint worldID, float timeStep, int maxSubSteps, float fixedTimeStep, 
+                        out int updatedEntityCount, 
                         out IntPtr updatedEntitiesPtr,
                         out int collidersCount,
                         out IntPtr collidersPtr);
 
 [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
-public static extern bool CreateHull(uint worldID, System.UInt64 meshKey,
+public static extern bool CreateHull(uint worldID, System.UInt64 meshKey, 
                             int hullCount, [MarshalAs(UnmanagedType.LPArray)] float[] hulls
     );
 
 [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
-public static extern bool CreateMesh(uint worldID, System.UInt64 meshKey,
+public static extern bool CreateMesh(uint worldID, System.UInt64 meshKey, 
                             int indexCount, [MarshalAs(UnmanagedType.LPArray)] int[] indices,
                             int verticesCount, [MarshalAs(UnmanagedType.LPArray)] float[] vertices
     );
@@ -481,6 +268,23 @@ public static extern bool DestroyMesh(uint worldID, System.UInt64 meshKey);
 [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
 public static extern bool CreateObject(uint worldID, ShapeData shapeData);
 
+/*  Remove old functionality
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern void CreateLinkset(uint worldID, int objectCount, ShapeData[] shapeDatas);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern void AddConstraint(uint worldID, uint id1, uint id2, 
+                        Vector3 frame1, Quaternion frame1rot,
+                        Vector3 frame2, Quaternion frame2rot,
+                        Vector3 lowLinear, Vector3 hiLinear, Vector3 lowAngular, Vector3 hiAngular);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern bool RemoveConstraintByID(uint worldID, uint id1);
+
+[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
+public static extern bool RemoveConstraint(uint worldID, uint id1, uint id2);
+ */
+
 [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
 public static extern Vector3 GetObjectPosition(uint WorldID, uint id);
 
@@ -496,7 +300,6 @@ public static extern bool SetObjectVelocity(uint worldID, uint id, Vector3 veloc
 [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
 public static extern bool SetObjectAngularVelocity(uint worldID, uint id, Vector3 angularVelocity);
 
-// Set the current force acting on the object
 [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
 public static extern bool SetObjectForce(uint worldID, uint id, Vector3 force);
 
@@ -537,8 +340,10 @@ public static extern Vector3 RecoverFromPenetration(uint worldID, uint id);
 // ===============================================================================
 [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
 public static extern void DumpBulletStatistics();
-*/
+
 // Log a debug message
+[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+public delegate void DebugLogCallback([MarshalAs(UnmanagedType.LPStr)]string msg);
 [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
 public static extern void SetDebugLogCallback(DebugLogCallback callback);
 
@@ -553,7 +358,6 @@ public static extern void SetDebugLogCallback(DebugLogCallback callback);
 // The names have a "2" tacked on. This will be removed as the C# code gets rebuilt
 //    and the old code is removed.
 
-// Functions use while converting from API1 to API2. Can be removed when totally converted.
 [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
 public static extern IntPtr GetSimHandle2(uint worldID);
 
@@ -564,25 +368,23 @@ public static extern IntPtr GetBodyHandleWorldID2(uint worldID, uint id);
 public static extern IntPtr GetBodyHandle2(IntPtr world, uint id);
 
 // ===============================================================================
-// Initialization and simulation
 [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
 public static extern IntPtr Initialize2(Vector3 maxPosition, IntPtr parms,
                                                                                         int maxCollisions,  IntPtr collisionArray,
-                                                                                        int maxUpdates, IntPtr updateArray,
-                                            DebugLogCallback logRoutine);
+                                                                                        int maxUpdates, IntPtr updateArray);
 
 [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
 public static extern bool UpdateParameter2(IntPtr world, uint localID, String parm, float value);
 
 [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
-public static extern void SetHeightMap2(IntPtr world, float[] heightmap);
+public static extern void SetHeightmap2(IntPtr world, float[] heightmap);
 
 [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
 public static extern void Shutdown2(IntPtr sim);
 
 [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
 public static extern int PhysicsStep2(IntPtr world, float timeStep, int maxSubSteps, float fixedTimeStep,
-                        out int updatedEntityCount,
+                        out int updatedEntityCount, 
                         out IntPtr updatedEntitiesPtr,
                         out int collidersCount,
                         out IntPtr collidersPtr);
@@ -590,98 +392,23 @@ public static extern int PhysicsStep2(IntPtr world, float timeStep, int maxSubSt
 [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
 public static extern bool PushUpdate2(IntPtr obj);
 
-// =====================================================================================
-// Mesh, hull, shape and body creation helper routines
-[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
-public static extern IntPtr CreateMeshShape2(IntPtr world,
-                int indicesCount, [MarshalAs(UnmanagedType.LPArray)] int[] indices,
-                int verticesCount, [MarshalAs(UnmanagedType.LPArray)] float[] vertices );
-
-[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
-public static extern IntPtr CreateHullShape2(IntPtr world,
-                int hullCount, [MarshalAs(UnmanagedType.LPArray)] float[] hulls);
-
-[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
-public static extern IntPtr BuildHullShapeFromMesh2(IntPtr world, IntPtr meshShape);
-
-[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
-public static extern IntPtr BuildNativeShape2(IntPtr world, ShapeData shapeData);
-
-[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
-public static extern bool IsNativeShape2(IntPtr shape);
-
-[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
-public static extern IntPtr BuildCapsuleShape2(IntPtr world, float radius, float height, Vector3 scale);
-
-[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
-public static extern IntPtr CreateCompoundShape2(IntPtr sim, bool enableDynamicAabbTree);
-
-[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
-public static extern int GetNumberOfCompoundChildren2(IntPtr cShape);
-
-[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
-public static extern void AddChildShapeToCompoundShape2(IntPtr cShape, IntPtr addShape, Vector3 pos, Quaternion rot);
-
-[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
-public static extern IntPtr GetChildShapeFromCompoundShapeIndex2(IntPtr cShape, int indx);
-
-[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
-public static extern IntPtr RemoveChildShapeFromCompoundShapeIndex2(IntPtr cShape, int indx);
-
-[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
-public static extern void RemoveChildShapeFromCompoundShape2(IntPtr cShape, IntPtr removeShape);
-
-[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
-public static extern IntPtr DuplicateCollisionShape2(IntPtr sim, IntPtr srcShape, uint id);
-
-[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
-public static extern IntPtr CreateBodyFromShapeAndInfo2(IntPtr sim, IntPtr shape, uint id, IntPtr constructionInfo);
-
-[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
-public static extern bool DeleteCollisionShape2(IntPtr world, IntPtr shape);
-
-[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
-public static extern int GetBodyType2(IntPtr obj);
-
-[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
-public static extern IntPtr CreateBodyFromShape2(IntPtr sim, IntPtr shape, uint id, Vector3 pos, Quaternion rot);
-
-[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
-public static extern IntPtr CreateBodyWithDefaultMotionState2(IntPtr shape, uint id, Vector3 pos, Quaternion rot);
-
-[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
-public static extern IntPtr CreateGhostFromShape2(IntPtr sim, IntPtr shape, uint id, Vector3 pos, Quaternion rot);
-
-[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
-public static extern IntPtr AllocateBodyInfo2(IntPtr obj);
-
-[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
-public static extern void ReleaseBodyInfo2(IntPtr obj);
-
-[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
-public static extern void DestroyObject2(IntPtr sim, IntPtr obj);
-
-// =====================================================================================
-// Terrain creation and helper routines
+/*
 [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
-public static extern IntPtr CreateHeightMapInfo2(IntPtr sim, uint id, Vector3 minCoords, Vector3 maxCoords,
-        [MarshalAs(UnmanagedType.LPArray)] float[] heightMap, float collisionMargin);
+public static extern IntPtr CreateMesh2(IntPtr world, int indicesCount, int* indices, int verticesCount, float* vertices );
 
 [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
-public static extern IntPtr FillHeightMapInfo2(IntPtr sim, IntPtr mapInfo, uint id, Vector3 minCoords, Vector3 maxCoords,
-        [MarshalAs(UnmanagedType.LPArray)] float[] heightMap, float collisionMargin);
+public static extern bool BuildHull2(IntPtr world, IntPtr mesh);
 
 [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
-public static extern bool ReleaseHeightMapInfo2(IntPtr heightMapInfo);
+public static extern bool ReleaseHull2(IntPtr world, IntPtr mesh);
 
 [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
-public static extern IntPtr CreateGroundPlaneShape2(uint id, float height, float collisionMargin);
+public static extern bool DestroyMesh2(IntPtr world, IntPtr mesh);
 
 [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
-public static extern IntPtr CreateTerrainShape2(IntPtr mapInfo);
+public static extern IntPtr CreateObject2(IntPtr world, ShapeData shapeData);
+*/
 
-// =====================================================================================
-// Constraint creation and helper routines
 [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
 public static extern IntPtr Create6DofConstraint2(IntPtr world, IntPtr obj1, IntPtr obj2,
                     Vector3 frame1loc, Quaternion frame1rot,
@@ -706,7 +433,7 @@ public static extern void SetConstraintEnable2(IntPtr constrain, float numericTr
 public static extern void SetConstraintNumSolverIterations2(IntPtr constrain, float iterations);
 
 [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
-public static extern bool SetFrames2(IntPtr constrain,
+public static extern bool SetFrames2(IntPtr constrain, 
                 Vector3 frameA, Quaternion frameArot, Vector3 frameB, Quaternion frameBrot);
 
 [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
@@ -733,108 +460,11 @@ public static extern bool SetConstraintParam2(IntPtr constrain, ConstraintParams
 [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
 public static extern bool DestroyConstraint2(IntPtr world, IntPtr constrain);
 
-// =====================================================================================
-// btCollisionWorld entries
 [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
-public static extern void UpdateSingleAabb2(IntPtr world, IntPtr obj);
+public static extern Vector3 AddObjectToWorld2(IntPtr world, IntPtr obj);
 
 [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
-public static extern void UpdateAabbs2(IntPtr world);
-
-[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
-public static extern bool GetForceUpdateAllAabbs2(IntPtr world);
-
-[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
-public static extern void SetForceUpdateAllAabbs2(IntPtr world, bool force);
-
-// =====================================================================================
-// btDynamicsWorld entries
-[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
-public static extern bool AddObjectToWorld2(IntPtr world, IntPtr obj);
-
-[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
-public static extern bool RemoveObjectFromWorld2(IntPtr world, IntPtr obj);
-
-[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
-public static extern bool AddConstraintToWorld2(IntPtr world, IntPtr constrain, bool disableCollisionsBetweenLinkedObjects);
-
-[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
-public static extern bool RemoveConstraintFromWorld2(IntPtr world, IntPtr constrain);
-// =====================================================================================
-// btCollisionObject entries
-[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
-public static extern Vector3 GetAnisotripicFriction2(IntPtr constrain);
-
-[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
-public static extern Vector3 SetAnisotripicFriction2(IntPtr constrain, Vector3 frict);
-
-[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
-public static extern bool HasAnisotripicFriction2(IntPtr constrain);
-
-[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
-public static extern void SetContactProcessingThreshold2(IntPtr obj, float val);
-
-[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
-public static extern float GetContactProcessingThreshold2(IntPtr obj);
-
-[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
-public static extern bool IsStaticObject2(IntPtr obj);
-
-[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
-public static extern bool IsKinematicObject2(IntPtr obj);
-
-[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
-public static extern bool IsStaticOrKinematicObject2(IntPtr obj);
-
-[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
-public static extern bool HasContactResponse2(IntPtr obj);
-
-[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
-public static extern void SetCollisionShape2(IntPtr sim, IntPtr obj, IntPtr shape);
-
-[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
-public static extern IntPtr GetCollisionShape2(IntPtr obj);
-
-[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
-public static extern int GetActivationState2(IntPtr obj);
-
-[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
-public static extern void SetActivationState2(IntPtr obj, int state);
-
-[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
-public static extern void SetDeactivationTime2(IntPtr obj, float dtime);
-
-[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
-public static extern float GetDeactivationTime2(IntPtr obj);
-
-[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
-public static extern void ForceActivationState2(IntPtr obj, ActivationState state);
-
-[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
-public static extern void Activate2(IntPtr obj, bool forceActivation);
-
-[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
-public static extern bool IsActive2(IntPtr obj);
-
-[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
-public static extern void SetRestitution2(IntPtr obj, float val);
-
-[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
-public static extern float GetRestitution2(IntPtr obj);
-
-[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
-public static extern void SetFriction2(IntPtr obj, float val);
-
-[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
-public static extern float GetFriction2(IntPtr obj);
-
-    /* Haven't defined the type 'Transform'
-[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
-public static extern Transform GetWorldTransform2(IntPtr obj);
-
-[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
-public static extern void setWorldTransform2(IntPtr obj, Transform trans);
-     */
+public static extern Vector3 RemoveObjectFromWorld2(IntPtr world, IntPtr obj);
 
 [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
 public static extern Vector3 GetPosition2(IntPtr obj);
@@ -843,290 +473,85 @@ public static extern Vector3 GetPosition2(IntPtr obj);
 public static extern Quaternion GetOrientation2(IntPtr obj);
 
 [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
-public static extern void SetTranslation2(IntPtr obj, Vector3 position, Quaternion rotation);
-
-[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
-public static extern IntPtr GetBroadphaseHandle2(IntPtr obj);
-
-[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
-public static extern void SetBroadphaseHandle2(IntPtr obj, IntPtr handle);
-
-    /*
-[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
-public static extern Transform GetInterpolationWorldTransform2(IntPtr obj);
-
-[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
-public static extern void SetInterpolationWorldTransform2(IntPtr obj, Transform trans);
-     */
-
-[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
-public static extern void SetInterpolationLinearVelocity2(IntPtr obj, Vector3 vel);
-
-[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
-public static extern void SetInterpolationAngularVelocity2(IntPtr obj, Vector3 vel);
-
-[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
-public static extern void SetInterpolationVelocity2(IntPtr obj, Vector3 linearVel, Vector3 angularVel);
-
-[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
-public static extern float GetHitFraction2(IntPtr obj);
-
-[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
-public static extern void SetHitFraction2(IntPtr obj, float val);
-
-[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
-public static extern CollisionFlags GetCollisionFlags2(IntPtr obj);
-
-[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
-public static extern CollisionFlags SetCollisionFlags2(IntPtr obj, CollisionFlags flags);
-
-[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
-public static extern CollisionFlags AddToCollisionFlags2(IntPtr obj, CollisionFlags flags);
-
-[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
-public static extern CollisionFlags RemoveFromCollisionFlags2(IntPtr obj, CollisionFlags flags);
-
-[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
-public static extern float GetCcdMotionThreshold2(IntPtr obj);
-
-[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
-public static extern void SetCcdMotionThreshold2(IntPtr obj, float val);
-
-[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
-public static extern float GetCcdSweptSphereRadius2(IntPtr obj);
-
-[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
-public static extern void SetCcdSweptSphereRadius2(IntPtr obj, float val);
-
-[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
-public static extern IntPtr GetUserPointer2(IntPtr obj);
-
-[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
-public static extern void SetUserPointer2(IntPtr obj, IntPtr val);
-
-// =====================================================================================
-// btRigidBody entries
-[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
-public static extern void ApplyGravity2(IntPtr obj);
-
-[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
-public static extern void SetGravity2(IntPtr obj, Vector3 val);
-
-[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
-public static extern Vector3 GetGravity2(IntPtr obj);
-
-[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
-public static extern void SetDamping2(IntPtr obj, float lin_damping, float ang_damping);
-
-[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
-public static extern float GetLinearDamping2(IntPtr obj);
-
-[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
-public static extern float GetAngularDamping2(IntPtr obj);
-
-[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
-public static extern float GetLinearSleepingThreshold2(IntPtr obj);
-
-[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
-public static extern float GetAngularSleepingThreshold2(IntPtr obj);
-
-[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
-public static extern void ApplyDamping2(IntPtr obj, float timeStep);
-
-[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
-public static extern void SetMassProps2(IntPtr obj, float mass, Vector3 inertia);
-
-[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
-public static extern Vector3 GetLinearFactor2(IntPtr obj);
-
-[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
-public static extern void SetLinearFactor2(IntPtr obj, Vector3 factor);
-
-    /*
-[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
-public static extern void SetCenterOfMassTransform2(IntPtr obj, Transform trans);
-     */
-
-[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
-public static extern void SetCenterOfMassByPosRot2(IntPtr obj, Vector3 pos, Quaternion rot);
-
-// Add a force to the object as if its mass is one.
-[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
-public static extern void ApplyCentralForce2(IntPtr obj, Vector3 force);
-
-// Set the force being applied to the object as if its mass is one.
-[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
-public static extern void SetObjectForce2(IntPtr obj, Vector3 force);
-
-[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
-public static extern Vector3 GetTotalForce2(IntPtr obj);
-
-[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
-public static extern Vector3 GetTotalTorque2(IntPtr obj);
-
-[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
-public static extern Vector3 GetInvInertiaDiagLocal2(IntPtr obj);
-
-[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
-public static extern void SetInvInertiaDiagLocal2(IntPtr obj, Vector3 inert);
-
-[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
-public static extern void SetSleepingThresholds2(IntPtr obj, float lin_threshold, float ang_threshold);
-
-[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
-public static extern void ApplyTorque2(IntPtr obj, Vector3 torque);
+public static extern bool SetTranslation2(IntPtr obj, Vector3 position, Quaternion rotation);
 
-// Apply force at the given point. Will add torque to the object.
 [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
-public static extern void ApplyForce2(IntPtr obj, Vector3 force, Vector3 pos);
+public static extern bool SetVelocity2(IntPtr obj, Vector3 velocity);
 
-// Apply impulse to the object. Same as "ApplycentralForce" but force scaled by object's mass.
 [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
-public static extern void ApplyCentralImpulse2(IntPtr obj, Vector3 imp);
+public static extern bool SetAngularVelocity2(IntPtr obj, Vector3 angularVelocity);
 
-// Apply impulse to the object's torque. Force is scaled by object's mass.
 [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
-public static extern void ApplyTorqueImpulse2(IntPtr obj, Vector3 imp);
+public static extern bool SetObjectForce2(IntPtr obj, Vector3 force);
 
-// Apply impulse at the point given. For is scaled by object's mass and effects both linear and angular forces.
 [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
-public static extern void ApplyImpulse2(IntPtr obj, Vector3 imp, Vector3 pos);
+public static extern bool AddObjectForce2(IntPtr obj, Vector3 force);
 
 [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
-public static extern void ClearForces2(IntPtr obj);
+public static extern bool SetCcdMotionThreshold2(IntPtr obj, float val);
 
 [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
-public static extern void ClearAllForces2(IntPtr obj);
+public static extern bool SetCcdSweepSphereRadius2(IntPtr obj, float val);
 
 [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
-public static extern void UpdateInertiaTensor2(IntPtr obj);
+public static extern bool SetDamping2(IntPtr obj, float lin_damping, float ang_damping);
 
 [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
-public static extern Vector3 GetCenterOfMassPosition2(IntPtr obj);
+public static extern bool SetDeactivationTime2(IntPtr obj, float val);
 
-    /*
 [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
-public static extern Transform GetCenterOfMassTransform2(IntPtr obj);
-     */
+public static extern bool SetSleepingThresholds2(IntPtr obj, float lin_threshold, float ang_threshold);
 
 [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
-public static extern Vector3 GetLinearVelocity2(IntPtr obj);
+public static extern bool SetContactProcessingThreshold2(IntPtr obj, float val);
 
 [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
-public static extern Vector3 GetAngularVelocity2(IntPtr obj);
+public static extern bool SetFriction2(IntPtr obj, float val);
 
 [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
-public static extern void SetLinearVelocity2(IntPtr obj, Vector3 val);
+public static extern bool SetRestitution2(IntPtr obj, float val);
 
 [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
-public static extern void SetAngularVelocity2(IntPtr obj, Vector3 angularVelocity);
+public static extern bool SetLinearVelocity2(IntPtr obj, Vector3 val);
 
 [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
-public static extern Vector3 GetVelocityInLocalPoint2(IntPtr obj, Vector3 pos);
+public static extern bool SetInterpolation2(IntPtr obj, Vector3 lin, Vector3 ang);
 
 [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
-public static extern void Translate2(IntPtr obj, Vector3 trans);
-
-[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
-public static extern void UpdateDeactivation2(IntPtr obj, float timeStep);
-
-[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
-public static extern bool WantsSleeping2(IntPtr obj);
-
-[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
-public static extern void SetAngularFactor2(IntPtr obj, float factor);
-
-[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
-public static extern void SetAngularFactorV2(IntPtr obj, Vector3 factor);
-
-[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
-public static extern Vector3 GetAngularFactor2(IntPtr obj);
-
-[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
-public static extern bool IsInWorld2(IntPtr obj);
-
-[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
-public static extern void AddConstraintRef2(IntPtr obj, IntPtr constrain);
-
-[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
-public static extern void RemoveConstraintRef2(IntPtr obj, IntPtr constrain);
-
-[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
-public static extern IntPtr GetConstraintRef2(IntPtr obj, int index);
-
-[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
-public static extern int GetNumConstraintRefs2(IntPtr obj);
-
-[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
-public static extern void SetCollisionFilterMask2(IntPtr body, uint filter, uint mask);
-
-// =====================================================================================
-// btCollisionShape entries
-
-[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
-public static extern float GetAngularMotionDisc2(IntPtr shape);
-
-[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
-public static extern float GetContactBreakingThreshold2(IntPtr shape, float defaultFactor);
-
-[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
-public static extern bool IsPolyhedral2(IntPtr shape);
-
-[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
-public static extern bool IsConvex2d2(IntPtr shape);
-
-[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
-public static extern bool IsConvex2(IntPtr shape);
-
-[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
-public static extern bool IsNonMoving2(IntPtr shape);
-
-[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
-public static extern bool IsConcave2(IntPtr shape);
-
-[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
-public static extern bool IsCompound2(IntPtr shape);
-
-[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
-public static extern bool IsSoftBody2(IntPtr shape);
-
-[DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
-public static extern bool IsInfinite2(IntPtr shape);
+public static extern CollisionFlags GetCollisionFlags2(IntPtr obj);
 
 [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
-public static extern void SetLocalScaling2(IntPtr shape, Vector3 scale);
+public static extern IntPtr SetCollisionFlags2(IntPtr obj, CollisionFlags flags);
 
 [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
-public static extern Vector3 GetLocalScaling2(IntPtr shape);
+public static extern IntPtr AddToCollisionFlags2(IntPtr obj, CollisionFlags flags);
 
 [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
-public static extern Vector3 CalculateLocalInertia2(IntPtr shape, float mass);
+public static extern IntPtr RemoveFromCollisionFlags2(IntPtr obj, CollisionFlags flags);
 
 [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
-public static extern int GetShapeType2(IntPtr shape);
+public static extern bool SetMassProps2(IntPtr obj, float mass, Vector3 inertia);
 
 [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
-public static extern void SetMargin2(IntPtr shape, float val);
+public static extern bool UpdateInertiaTensor2(IntPtr obj);
 
 [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
-public static extern float GetMargin2(IntPtr shape);
+public static extern bool SetGravity2(IntPtr obj, Vector3 val);
 
-// =====================================================================================
-// Debugging
 [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
-public static extern void DumpRigidBody2(IntPtr sim, IntPtr collisionObject);
+public static extern IntPtr ClearForces2(IntPtr obj);
 
 [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
-public static extern void DumpCollisionShape2(IntPtr sim, IntPtr collisionShape);
+public static extern IntPtr ClearAllForces2(IntPtr obj);
 
 [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
-public static extern void DumpConstraint2(IntPtr sim, IntPtr constrain);
+public static extern bool SetMargin2(IntPtr obj, float val);
 
 [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
-public static extern void DumpAllInfo2(IntPtr sim);
+public static extern bool UpdateSingleAabb2(IntPtr world, IntPtr obj);
 
 [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
-public static extern void DumpMapInfo2(IntPtr sim, IntPtr manInfo);
+public static extern bool DestroyObject2(IntPtr world, uint id);
 
 [DllImport("BulletSim", CallingConvention = CallingConvention.Cdecl), SuppressUnmanagedCodeSecurity]
 public static extern void DumpPhysicsStatistics2(IntPtr sim);
diff --git a/OpenSim/Region/Physics/Manager/PhysicsActor.cs b/OpenSim/Region/Physics/Manager/PhysicsActor.cs
index 5af6373..14f65b8 100644
--- a/OpenSim/Region/Physics/Manager/PhysicsActor.cs
+++ b/OpenSim/Region/Physics/Manager/PhysicsActor.cs
@@ -340,12 +340,6 @@ namespace OpenSim.Region.Physics.Manager
         /// Getting this returns the velocity calculated by physics scene updates, using factors such as target velocity,
         /// time to accelerate and collisions.
         /// </remarks>
-        public virtual Vector3 TargetVelocity
-        {
-            get { return Velocity; }
-            set { Velocity = value; }
-        }
-
         public abstract Vector3 Velocity { get; set; }
 
         public abstract Vector3 Torque { get; set; }
diff --git a/OpenSim/Region/Physics/OdePlugin/ODECharacter.cs b/OpenSim/Region/Physics/OdePlugin/ODECharacter.cs
index c736557..f3b0630 100644
--- a/OpenSim/Region/Physics/OdePlugin/ODECharacter.cs
+++ b/OpenSim/Region/Physics/OdePlugin/ODECharacter.cs
@@ -100,7 +100,7 @@ namespace OpenSim.Region.Physics.OdePlugin
         private bool m_hackSentFly = false;
         private int m_requestedUpdateFrequency = 0;
         private Vector3 m_taintPosition;
-        internal bool m_avatarplanted = false;
+
         /// <summary>
         /// Hold set forces so we can process them outside physics calculations.  This prevents race conditions if we set force
         /// while calculatios are going on
@@ -413,7 +413,7 @@ namespace OpenSim.Region.Physics.OdePlugin
             set
             {
                 m_iscollidingObj = value;
-                if (value && !m_avatarplanted)
+                if (value)
                     m_pidControllerActive = false;
                 else
                     m_pidControllerActive = true;
diff --git a/OpenSim/Region/Physics/OdePlugin/ODEPrim.cs b/OpenSim/Region/Physics/OdePlugin/ODEPrim.cs
index a59f63f..2e78de5 100644
--- a/OpenSim/Region/Physics/OdePlugin/ODEPrim.cs
+++ b/OpenSim/Region/Physics/OdePlugin/ODEPrim.cs
@@ -67,14 +67,6 @@ namespace OpenSim.Region.Physics.OdePlugin
         private int m_expectedCollisionContacts = 0;
 
         /// <summary>
-        /// Gets collide bits so that we can still perform land collisions if a mesh fails to load.
-        /// </summary>
-        private int BadMeshAssetCollideBits
-        {
-            get { return m_isphysical ? (int)CollisionCategories.Land : 0; }
-        }
-
-        /// <summary>
         /// Is this prim subject to physics?  Even if not, it's still solid for collision purposes.
         /// </summary>
         public override bool IsPhysical
@@ -164,7 +156,7 @@ namespace OpenSim.Region.Physics.OdePlugin
 
         private PrimitiveBaseShape _pbs;
         private OdeScene _parent_scene;
-        
+
         /// <summary>
         /// The physics space which contains prim geometries
         /// </summary>
@@ -3341,6 +3333,7 @@ Console.WriteLine(" JointCreateFixed");
             m_material = pMaterial;
         }
 
+
         private void CheckMeshAsset()
         {
             if (_pbs.SculptEntry && !m_assetFailed && _pbs.SculptTexture != UUID.Zero)
@@ -3350,14 +3343,14 @@ Console.WriteLine(" JointCreateFixed");
                     {
                         RequestAssetDelegate assetProvider = _parent_scene.RequestAssetMethod;
                         if (assetProvider != null)
-                            assetProvider(_pbs.SculptTexture, MeshAssetReceived);
+                            assetProvider(_pbs.SculptTexture, MeshAssetReveived);
                     });
             }
         }
 
-        private void MeshAssetReceived(AssetBase asset)
+        void MeshAssetReveived(AssetBase asset)
         {
-            if (asset != null && asset.Data != null && asset.Data.Length > 0)
+            if (asset.Data != null && asset.Data.Length > 0)
             {
                 if (!_pbs.SculptEntry)
                     return;
@@ -3370,12 +3363,6 @@ Console.WriteLine(" JointCreateFixed");
                 m_taintshape = true;
                _parent_scene.AddPhysicsActorTaint(this);
             }
-            else
-            {
-                m_log.WarnFormat(
-                    "[ODE PRIM]: Could not get mesh/sculpt asset {0} for {1} at {2} in {3}",
-                    _pbs.SculptTexture, Name, _position, _parent_scene.Name);
-            }
         }          
     }
-}
+}
\ No newline at end of file
diff --git a/OpenSim/Region/Physics/OdePlugin/OdeScene.cs b/OpenSim/Region/Physics/OdePlugin/OdeScene.cs
index d53bd90..7a50c4c 100644
--- a/OpenSim/Region/Physics/OdePlugin/OdeScene.cs
+++ b/OpenSim/Region/Physics/OdePlugin/OdeScene.cs
@@ -501,8 +501,6 @@ namespace OpenSim.Region.Physics.OdePlugin
         public int physics_logging_interval = 0;
         public bool physics_logging_append_existing_logfile = false;
 
-        private bool avplanted = false;
-        private bool av_av_collisions_off = false;
 
         public d.Vector3 xyz = new d.Vector3(128.1640f, 128.3079f, 25.7600f);
         public d.Vector3 hpr = new d.Vector3(125.5000f, -17.0000f, 0.0000f);
@@ -646,9 +644,6 @@ namespace OpenSim.Region.Physics.OdePlugin
                     avMovementDivisorWalk = physicsconfig.GetFloat("av_movement_divisor_walk", 1.3f);
                     avMovementDivisorRun = physicsconfig.GetFloat("av_movement_divisor_run", 0.8f);
                     avCapRadius = physicsconfig.GetFloat("av_capsule_radius", 0.37f);
-                    avplanted = physicsconfig.GetBoolean("av_planted", false);
-                    av_av_collisions_off = physicsconfig.GetBoolean("av_av_collisions_off", false);
-
                     IsAvCapsuleTilted = physicsconfig.GetBoolean("av_capsule_tilted", false);
 
                     contactsPerCollision = physicsconfig.GetInt("contacts_per_collision", 80);
@@ -668,8 +663,6 @@ namespace OpenSim.Region.Physics.OdePlugin
                     meshSculptLOD = physicsconfig.GetFloat("mesh_lod", 32f);
                     MeshSculptphysicalLOD = physicsconfig.GetFloat("mesh_physical_lod", 16f);
                     m_filterCollisions = physicsconfig.GetBoolean("filter_collisions", false);
-                    
-                    
 
                     if (Environment.OSVersion.Platform == PlatformID.Unix)
                     {
@@ -1316,10 +1309,6 @@ namespace OpenSim.Region.Physics.OdePlugin
                 if ((p1 is OdePrim) && (((OdePrim)p1).m_isVolumeDetect))
                     skipThisContact = true;   // No collision on volume detect prims
 
-                if (av_av_collisions_off)
-                    if ((p1 is OdeCharacter) && (p2 is OdeCharacter))
-                        skipThisContact = true;
-
                 if (!skipThisContact && (p2 is OdePrim) && (((OdePrim)p2).m_isVolumeDetect))
                     skipThisContact = true;   // No collision on volume detect prims
 
@@ -1983,8 +1972,7 @@ namespace OpenSim.Region.Physics.OdePlugin
 
             newAv.Flying = isFlying;
             newAv.MinimumGroundFlightOffset = minimumGroundFlightOffset;
-            newAv.m_avatarplanted = avplanted;
-
+            
             return newAv;
         }
 
@@ -1999,7 +1987,6 @@ namespace OpenSim.Region.Physics.OdePlugin
 
         internal void AddCharacter(OdeCharacter chr)
         {
-            chr.m_avatarplanted = avplanted;
             if (!_characters.Contains(chr))
             {
                 _characters.Add(chr);
@@ -4320,4 +4307,4 @@ namespace OpenSim.Region.Physics.OdePlugin
             m_stats[ODEPrimUpdateFrameMsStatName] = 0;
         }
     }
-}
+}
\ No newline at end of file