public BSConstraintHinge(BulletWorld world, BulletBody obj1, BulletBody obj2,
     Vector3 pivotInA, Vector3 pivotInB,
     Vector3 axisInA, Vector3 axisInB,
     bool useLinearReferenceFrameA, bool disableCollisionsBetweenLinkedBodies)
     : base(world)
 {
     m_body1 = obj1;
     m_body2 = obj2;
     m_constraint = PhysicsScene.PE.CreateHingeConstraint(world, obj1, obj2,
         pivotInA, pivotInB, axisInA, axisInB,
         useLinearReferenceFrameA, disableCollisionsBetweenLinkedBodies);
     m_enabled = true;
 }

 public BSConstraintConeTwist(BulletWorld world, BulletBody obj1, BulletBody obj2,
                 Vector3 frameInAloc, Quaternion frameInArot,
                 Vector3 frameInBloc, Quaternion frameInBrot,
                 bool disableCollisionsBetweenLinkedBodies)
     : base(world)
 {
     m_body1 = obj1;
     m_body2 = obj2;
     m_constraint = PhysicsScene.PE.CreateConeTwistConstraint(world, obj1, obj2,
                             frameInAloc, frameInArot, frameInBloc, frameInBrot,
                             disableCollisionsBetweenLinkedBodies);
     m_enabled = true;
 }

    public BSConstraintSpring(BulletWorld world, BulletBody obj1, BulletBody obj2,
                    Vector3 frame1Loc, Quaternion frame1Rot,
                    Vector3 frame2Loc, Quaternion frame2Rot,
                    bool useLinearReferenceFrameA, bool disableCollisionsBetweenLinkedBodies)
        :base(world, obj1, obj2)
    {
        m_constraint = PhysicsScene.PE.Create6DofSpringConstraint(world, obj1, obj2,
                                frame1Loc, frame1Rot, frame2Loc, frame2Rot,
                                useLinearReferenceFrameA, disableCollisionsBetweenLinkedBodies);
        m_enabled = true;

        PhysicsScene.DetailLog("{0},BSConstraintSpring,create,wID={1}, rID={2}, rBody={3}, cID={4}, cBody={5}",
                            obj1.ID, world.worldID, obj1.ID, obj1.AddrString, obj2.ID, obj2.AddrString);
        PhysicsScene.DetailLog("{0},BSConstraintSpring,create,  f1Loc={1},f1Rot={2},f2Loc={3},f2Rot={4},usefA={5},disCol={6}",
                    m_body1.ID, frame1Loc, frame1Rot, frame2Loc, frame2Rot, useLinearReferenceFrameA, disableCollisionsBetweenLinkedBodies);
    }

 // Create a btGeneric6DofConstraint
 public BSConstraint6Dof(BulletWorld world, BulletBody obj1, BulletBody obj2,
     Vector3 frame1, Quaternion frame1rot,
     Vector3 frame2, Quaternion frame2rot,
     bool useLinearReferenceFrameA, bool disableCollisionsBetweenLinkedBodies)
     : base(world)
 {
     m_body1 = obj1;
     m_body2 = obj2;
     m_constraint = PhysicsScene.PE.Create6DofConstraint(m_world, m_body1, m_body2,
         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.AddrString, obj2.ID, obj2.AddrString);
 }

        // Get the constraint between two bodies. There can be only one.
        // Return 'true' if a constraint was found.
        public bool TryGetConstraint(BulletBody body1, BulletBody body2, out BSConstraint returnConstraint)
        {
            bool found = false;
            BSConstraint foundConstraint = null;

            uint lookingID1 = body1.ID;
            uint lookingID2 = body2.ID;
            lock (m_constraints)
            {
                foreach (BSConstraint constrain in m_constraints)
                {
                    if ((constrain.Body1.ID == lookingID1 && constrain.Body2.ID == lookingID2)
                        || (constrain.Body1.ID == lookingID2 && constrain.Body2.ID == lookingID1))
                    {
                        foundConstraint = constrain;
                        found = true;
                        break;
                    }
                }
            }
            returnConstraint = foundConstraint;
            return found;
        }

        protected BSPhysObject(BSScene parentScene, uint localID, string name, string typeName)
        {
            PhysicsScene = parentScene;
            LocalID = localID;
            PhysObjectName = name;
            Name = name; // PhysicsActor also has the name of the object. Someday consolidate.
            TypeName = typeName;

            // Oddity if object is destroyed and recreated very quickly it could still have the old body.
            if (!PhysBody.HasPhysicalBody)
                PhysBody = new BulletBody(localID);

            // The collection of things that push me around
            PhysicalActors = new BSActorCollection(PhysicsScene);

            // Initialize variables kept in base.
            GravityMultiplier = 1.0f;
            Gravity = new OMV.Vector3(0f, 0f, BSParam.Gravity);

            PrimAssetState = PrimAssetCondition.Unknown;

            // Default material type. Also sets Friction, Restitution and Density.
            SetMaterial((int)MaterialAttributes.Material.Wood);

            CollisionCollection = new CollisionEventUpdate();
            CollisionsLastTick = CollisionCollection;
            SubscribedEventsMs = 0;
            CollidingStep = 0;
            TrueCollidingStep = 0;
            CollisionAccumulation = 0;
            ColliderIsMoving = false;
            CollisionScore = 0;

            // All axis free.
            LockedLinearAxis = LockedAxisFree;
            LockedAngularAxis = LockedAxisFree;
        }

 public abstract BulletConstraint GetConstraintRef(BulletBody obj, int index);

 public abstract void RemoveConstraintRef(BulletBody obj, BulletConstraint constrain);

 public abstract void AddConstraintRef(BulletBody obj, BulletConstraint constrain);

 public abstract bool IsInWorld(BulletWorld world, BulletBody obj);

 public abstract Vector3 GetLinearVelocity(BulletBody obj);

 // Remove all constraints that reference the passed body.
 // Return 'true' if any constraints were destroyed.
 public bool RemoveAndDestroyConstraint(BulletBody body1)
 {
     List<BSConstraint> toRemove = new List<BSConstraint>();
     uint lookingID = body1.ID;
     lock (m_constraints)
     {
         foreach (BSConstraint constrain in m_constraints)
         {
             if (constrain.Body1.ID == lookingID || constrain.Body2.ID == lookingID)
             {
                 toRemove.Add(constrain);
             }
         }
         foreach (BSConstraint constrain in toRemove)
         {
             m_constraints.Remove(constrain);
             constrain.Dispose();
         }
     }
     return (toRemove.Count > 0);
 }

 // =====================================================================================
 // Debugging
 public virtual void DumpRigidBody(BulletWorld sim, BulletBody collisionObject)
 {
 }

 public abstract void UpdateDeactivation(BulletBody obj, float timeStep);

 public abstract void Translate(BulletBody obj, Vector3 trans);

 public abstract Vector3 GetVelocityInLocalPoint(BulletBody obj, Vector3 pos);

 public abstract void SetAngularVelocity(BulletBody obj, Vector3 angularVelocity);

 public abstract void SetLinearVelocity(BulletBody obj, Vector3 val);

 public abstract Vector3 GetAngularVelocity(BulletBody obj);

 public abstract int GetNumConstraintRefs(BulletBody obj);