public override float GetContactBreakingThreshold(BulletShape pShape, float defaultFactor)
 {
     CollisionShape shape = (pShape as BulletShapeXNA).shape;
     return shape.GetContactBreakingThreshold(defaultFactor);
 }

 public override bool DeleteCollisionShape(BulletWorld pWorld, BulletShape pShape)
 {
     //TODO:
     return false;
 }

 public override Vector3 CalculateLocalInertia(BulletShape pShape, float pphysMass)
 {
     CollisionShape shape = (pShape as BulletShapeXNA).shape;
     IndexedVector3 inertia = IndexedVector3.Zero;
     shape.CalculateLocalInertia(pphysMass, out inertia);
     return new Vector3(inertia.X, inertia.Y, inertia.Z);
 }

        public override BulletBody CreateBodyWithDefaultMotionState(BulletShape pShape, uint pLocalID,
            Vector3 pRawPosition, Quaternion pRawOrientation)
        {
            IndexedMatrix mat =
                IndexedMatrix.CreateFromQuaternion(new IndexedQuaternion(pRawOrientation.X, pRawOrientation.Y,
                    pRawOrientation.Z, pRawOrientation.W));
            mat._origin = new IndexedVector3(pRawPosition.X, pRawPosition.Y, pRawPosition.Z);

            CollisionShape shape = (pShape as BulletShapeXNA).shape;

            // TODO: Feed Update array into null
            RigidBody body = new RigidBody(0, new DefaultMotionState(mat, IndexedMatrix.Identity), shape,
                IndexedVector3.Zero);
            body.SetWorldTransform(mat);
            body.SetUserPointer(pLocalID);
            return new BulletBodyXNA(pLocalID, body);
        }

 public override void SetShapeCollisionMargin(BulletShape pShape, float pMargin)
 {
     CollisionShape shape = (pShape as BulletShapeXNA).shape;
     shape.SetMargin(pMargin);
 }

 public override bool ReferenceSame(BulletShape other)
 {
     BulletShapeXNA otheru = other as BulletShapeXNA;
     return (otheru != null) && (this.shape == otheru.shape);
 }

 public override bool IsInfinite(BulletShape pShape)
 {
     CollisionShape shape = (pShape as BulletShapeXNA).shape;
     return shape.IsInfinite();
 }

 public override bool IsNativeShape(BulletShape pShape)
 {
     CollisionShape shape = (pShape as BulletShapeXNA).shape;
     bool ret;
     switch (shape.GetShapeType())
     {
         case BroadphaseNativeTypes.BOX_SHAPE_PROXYTYPE:
         case BroadphaseNativeTypes.CONE_SHAPE_PROXYTYPE:
         case BroadphaseNativeTypes.SPHERE_SHAPE_PROXYTYPE:
         case BroadphaseNativeTypes.CYLINDER_SHAPE_PROXYTYPE:
             ret = true;
             break;
         default:
             ret = false;
             break;
     }
     return ret;
 }

 public override int GetShapeType(BulletShape pShape)
 {
     CollisionShape shape = (pShape as BulletShapeXNA).shape;
     return (int)shape.GetShapeType();
 }

 public override bool IsConvex2d(BulletShape pShape)
 {
     CollisionShape shape = (pShape as BulletShapeXNA).shape;
     return shape.IsConvex2d();
 }

 public override int GetNumberOfCompoundChildren(BulletShape pCompoundShape)
 {
     CompoundShape compoundshape = (pCompoundShape as BulletShapeXNA).shape as CompoundShape;
     return compoundshape.GetNumChildShapes();
 }

 public override float GetMargin(BulletShape pShape)
 {
     CollisionShape shape = (pShape as BulletShapeXNA).shape;
     return shape.GetMargin();
 }

 public override Vector3 GetLocalScaling(BulletShape pShape)
 {
     CollisionShape shape = (pShape as BulletShapeXNA).shape;
     IndexedVector3 scale = shape.GetLocalScaling();
     return new Vector3(scale.X, scale.Y, scale.Z);
 }

        //LinksetRoot.PhysShape.ptr, newShape.ptr, displacementPos, displacementRot
        public override void AddChildShapeToCompoundShape(BulletShape pCShape, BulletShape paddShape,
            Vector3 displacementPos, Quaternion displacementRot)
        {
            IndexedMatrix relativeTransform = new IndexedMatrix();
            CompoundShape compoundshape = (pCShape as BulletShapeXNA).shape as CompoundShape;
            CollisionShape addshape = (paddShape as BulletShapeXNA).shape;

            relativeTransform._origin = new IndexedVector3(displacementPos.X, displacementPos.Y, displacementPos.Z);
            relativeTransform.SetRotation(new IndexedQuaternion(displacementRot.X, displacementRot.Y, displacementRot.Z,
                displacementRot.W));
            compoundshape.AddChildShape(ref relativeTransform, addshape);
        }

 public override bool IsNonMoving(BulletShape pShape)
 {
     CollisionShape shape = (pShape as BulletShapeXNA).shape;
     return shape.IsNonMoving();
 }

 public override void SetLocalScaling(BulletShape pShape, Vector3 pScale)
 {
     CollisionShape shape = (pShape as BulletShapeXNA).shape;
     IndexedVector3 vec = new IndexedVector3(pScale.X, pScale.Y, pScale.Z);
     shape.SetLocalScaling(ref vec);
 }

 public override bool IsPolyhedral(BulletShape pShape)
 {
     CollisionShape shape = (pShape as BulletShapeXNA).shape;
     return shape.IsPolyhedral();
 }

 public override void UpdateChildTransform(BulletShape pShape, int childIndex, Vector3 pos, Quaternion rot,
     bool shouldRecalculateLocalAabb)
 {
     /* TODO */
 }

 public override bool IsSoftBody(BulletShape pShape)
 {
     CollisionShape shape = (pShape as BulletShapeXNA).shape;
     return shape.IsSoftBody();
 }

 public override BulletShape BuildHullShapeFromMesh(BulletWorld world, BulletShape meshShape, HACDParams parms)
 {
     /* TODO */
     return null;
 }