1 files changed, 661 insertions, 703 deletions

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);
     }
 }
 }