public abstract bool IsConvex2d(BulletShape shape);

 public BSShapeHull(BulletShape pShape) : base(pShape)
 {
 }

 // Loop through all the known hulls and return the description based on the physical address.
 public static bool TryGetHullByPtr(BulletShape pShape, out BSShapeHull outHull)
 {
     bool ret = false;
     BSShapeHull foundDesc = null;
     lock (Hulls)
     {
         foreach (BSShapeHull sh in Hulls.Values)
         {
             if (sh.physShapeInfo.ReferenceSame(pShape))
             {
                 foundDesc = sh;
                 ret = true;
                 break;
             }
         }
     }
     outHull = foundDesc;
     return ret;
 }

 public BSShapeNative(BulletShape pShape)
     : base(pShape)
 {
 }

 // Loop through all the known meshes and return the description based on the physical address.
 public static bool TryGetMeshByPtr(BulletShape pShape, out BSShapeMesh outMesh)
 {
     bool ret = false;
     BSShapeMesh foundDesc = null;
     lock (Meshes)
     {
         foreach (BSShapeMesh sm in Meshes.Values)
         {
             if (sm.physShapeInfo.ReferenceSame(pShape))
             {
                 foundDesc = sm;
                 ret = true;
                 break;
             }
         }
     }
     outMesh = foundDesc;
     return ret;
 }

 public BSShapeConvexHull(BulletShape pShape) : base(pShape)
 {
 }

 public BSShape(BulletShape pShape)
 {
     referenceCount = 1;
     lastReferenced = DateTime.Now;
     physShapeInfo = pShape;
     shapeInfo = new ShapeInfoInfo();
 }

 public abstract void RecalculateCompoundShapeLocalAabb(BulletShape cShape);

 public abstract void RemoveChildShapeFromCompoundShape(BulletShape cShape, BulletShape removeShape);

 public abstract bool IsPolyhedral(BulletShape shape);

 public abstract bool IsSoftBody(BulletShape shape);

 public abstract bool IsNonMoving(BulletShape shape);

 public abstract bool IsNativeShape(BulletShape shape);

 public abstract bool IsInfinite(BulletShape shape);

 public static bool TryGetCompoundByPtr(BulletShape pShape, out BSShapeCompound outCompound)
 {
     lock (CompoundShapes)
     {
         string addr = pShape.AddrString;
         return CompoundShapes.TryGetValue(addr, out outCompound);
     }
 }

 public abstract BulletShape RemoveChildShapeFromCompoundShapeIndex(BulletShape cShape, int indx);

 // Sometimes we have a pointer to a collision shape but don't know what type it is.
 // Figure out type and call the correct dereference routine.
 // Called at taint-time.
 void DereferenceAnonCollisionShape(BSScene physicsScene, BulletShape pShape)
 {
     // TODO: figure a better way to go through all the shape types and find a possible instance.
     physicsScene.DetailLog("{0},BSShapeCompound.DereferenceAnonCollisionShape,shape={1}",
         BSScene.DetailLogZero, pShape);
     BSShapeMesh meshDesc;
     if (BSShapeMesh.TryGetMeshByPtr(pShape, out meshDesc))
     {
         meshDesc.Dereference(physicsScene);
         // physicsScene.DetailLog("{0},BSShapeCompound.DereferenceAnonCollisionShape,foundMesh,shape={1}", BSScene.DetailLogZero, pShape);
     }
     else
     {
         BSShapeHull hullDesc;
         if (BSShapeHull.TryGetHullByPtr(pShape, out hullDesc))
         {
             hullDesc.Dereference(physicsScene);
             // physicsScene.DetailLog("{0},BSShapeCompound.DereferenceAnonCollisionShape,foundHull,shape={1}", BSScene.DetailLogZero, pShape);
         }
         else
         {
             BSShapeConvexHull chullDesc;
             if (BSShapeConvexHull.TryGetConvexHullByPtr(pShape, out chullDesc))
             {
                 chullDesc.Dereference(physicsScene);
                 // physicsScene.DetailLog("{0},BSShapeCompound.DereferenceAnonCollisionShape,foundConvexHull,shape={1}", BSScene.DetailLogZero, pShape);
             }
             else
             {
                 BSShapeGImpact gImpactDesc;
                 if (BSShapeGImpact.TryGetGImpactByPtr(pShape, out gImpactDesc))
                 {
                     gImpactDesc.Dereference(physicsScene);
                     // physicsScene.DetailLog("{0},BSShapeCompound.DereferenceAnonCollisionShape,foundgImpact,shape={1}", BSScene.DetailLogZero, pShape);
                 }
                 else
                 {
                     // Didn't find it in the lists of specific types. It could be compound.
                     BSShapeCompound compoundDesc;
                     if (TryGetCompoundByPtr(pShape, out compoundDesc))
                     {
                         compoundDesc.Dereference(physicsScene);
                         // physicsScene.DetailLog("{0},BSShapeCompound.DereferenceAnonCollisionShape,recursiveCompoundShape,shape={1}", BSScene.DetailLogZero, pShape);
                     }
                     else
                     {
                         // If none of the above, maybe it is a simple native shape.
                         if (physicsScene.PE.IsNativeShape(pShape))
                         {
                             // physicsScene.DetailLog("{0},BSShapeCompound.DereferenceAnonCollisionShape,assumingNative,shape={1}", BSScene.DetailLogZero, pShape);
                             BSShapeNative nativeShape = new BSShapeNative(pShape);
                             nativeShape.Dereference(physicsScene);
                         }
                         else
                         {
                             physicsScene.Logger.WarnFormat(
                                 "{0} DereferenceAnonCollisionShape. Did not find shape. {1}",
                                 LogHeader, pShape);
                         }
                     }
                 }
             }
         }
     }
 }

 public abstract void SetCollisionShape(BulletWorld sim, BulletBody obj, BulletShape shape);

 public BSShapeGImpact(BulletShape pShape) : base(pShape)
 {
 }

 public abstract void SetLocalScaling(BulletShape shape, Vector3 scale);