protected override void OnInitializePhysics()
        {
            BoxShape boxA = new BoxShape(new Vector3(1, 1, 1));
            boxA.Margin = 0;

            BoxShape boxB = new BoxShape(new Vector3(0.5f, 0.5f, 0.5f));
            boxB.Margin = 0;

            objects[0] = new CollisionObject();
            objects[1] = new CollisionObject();

            objects[0].CollisionShape = boxA;
            objects[1].CollisionShape = boxB;

            // collision configuration contains default setup for memory, collision setup
            CollisionConf = new DefaultCollisionConfiguration();
            Dispatcher = new CollisionDispatcher(CollisionConf);

            Broadphase = new AxisSweep3(new Vector3(-1000, -1000, -1000), new Vector3(1000, 1000, 1000));

            World = new DiscreteDynamicsWorld(Dispatcher, Broadphase, null, CollisionConf);
            World.Gravity = new Vector3(0, -10, 0);
            IsDebugDrawEnabled = true;

            //World.AddCollisionObject(objects[0]);
            World.AddCollisionObject(objects[1]);

            Quaternion rotA = new Quaternion(0.739f, -0.204f, 0.587f, 0.257f);
            rotA.Normalize();

            objects[0].WorldTransform = Matrix.RotationQuaternion(rotA) * Matrix.Translation(0, 3, 0);
            objects[1].WorldTransform = Matrix.Translation(0, 4.248f, 0);
        }

 public void Render(CollisionObject body)
 {
     switch (body.CollisionShape.ShapeType)
     {
         case BroadphaseNativeType.SoftBodyShape:
             device.SetTransform(TransformState.World, Matrix.Identity);
             RenderSoftBody(body as SoftBody);
             break;
         case BroadphaseNativeType.CompoundShape:
             CompoundShape compoundShape = body.CollisionShape as CompoundShape;
             //if (compoundShape.NumChildShapes == 0)
             //    return;
             foreach (CompoundShapeChild child in compoundShape.ChildList)
             {
                 device.SetTransform(TransformState.World,
                     MathHelper.Convert(child.Transform) * MathHelper.Convert(body.WorldTransform));
                 Render(child.ChildShape);
             }
             break;
         default:
             device.SetTransform(TransformState.World, MathHelper.Convert(body.WorldTransform));
             Render(body.CollisionShape);
             break;
     }
 }

        /// <summary>
        /// Create a data holder without a LThing object.
        /// </summary>
        /// <param name="collisionGroup">The collision group of the object</param>
        /// <param name="name">The name of the object, excluding an ID</param>
        /// <param name="owner">The collision object this data holder is attached to</param>
        public CollisionObjectDataHolder(CollisionObject owner, PonykartCollisionGroups collisionGroup, string name)
        {
            this.Owner = owner;
            this.CollisionGroup = collisionGroup;
            this.Name = name;

            this.ID = IDs.Random;
        }

 public override float AddSingleResult(ManifoldPoint cp, CollisionObject colObj0, int partId0, int index0, CollisionObject colObj1, int partId1, int index1)
 {
     if (colObj0.UserObject != null && colObj0.UserObject is IPhysicObject)
     {
         objs.Add(colObj0.UserObject as IPhysicObject);
     }
     return 0;
 }

 public void Render(CollisionObject body)
 {
     if (body.CollisionShape.ShapeType == BroadphaseNativeType.SoftBodyShape)
     {
         RenderSoftBody(body as SoftBody);
     }
     else
     {
         Render(body.CollisionShape);
     }
 }

        //called by Physics World just before rigid body is added to world.
        //the current rigid body properties are used to rebuild the rigid body.
        internal virtual bool _BuildCollisionObject()
        {
            BPhysicsWorld world = BPhysicsWorld.Get();
            if (m_collisionObject != null)
            {
                if (isInWorld && world != null)
                {
                    world.RemoveCollisionObject(m_collisionObject);
                }
            }

            if (transform.localScale != UnityEngine.Vector3.one)
            {
                Debug.LogError("The local scale on this collision shape is not one. Bullet physics does not support scaling on a rigid body world transform. Instead alter the dimensions of the CollisionShape.");
            }

            m_collisionShape = GetComponent<BCollisionShape>();
            if (m_collisionShape == null)
            {
                Debug.LogError("There was no collision shape component attached to this BRigidBody. " + name);
                return false;
            }

            CollisionShape cs = m_collisionShape.GetCollisionShape();
            //rigidbody is dynamic if and only if mass is non zero, otherwise static

            if (m_collisionObject == null)
            {
                m_collisionObject = new CollisionObject();
                m_collisionObject.CollisionShape = cs;
                m_collisionObject.UserObject = this;

                BulletSharp.Math.Matrix worldTrans;
                BulletSharp.Math.Quaternion q = transform.rotation.ToBullet();
                BulletSharp.Math.Matrix.RotationQuaternion(ref q, out worldTrans);
                worldTrans.Origin = transform.position.ToBullet();
                m_collisionObject.WorldTransform = worldTrans;
                m_collisionObject.CollisionFlags = m_collisionFlags;
            }
            else {
                m_collisionObject.CollisionShape = cs;
                BulletSharp.Math.Matrix worldTrans;
                BulletSharp.Math.Quaternion q = transform.rotation.ToBullet();
                BulletSharp.Math.Matrix.RotationQuaternion(ref q, out worldTrans);
                worldTrans.Origin = transform.position.ToBullet();
                m_collisionObject.WorldTransform = worldTrans;
                m_collisionObject.CollisionFlags = m_collisionFlags;
            }
            return true;
        }

 public KinematicClosestNotMeConvexResultCallback(CollisionObject me, Vector3 up, float minSlopeDot)
     : base(ref zero, ref zero)
 {
     _me = me;
     _up = up;
     _minSlopeDot = minSlopeDot;
 }

 public KinematicClosestNotMeRayResultCallback(CollisionObject me)
     : base(ref zero, ref zero)
 {
     _me = me;
 }

		public void ContactTest(CollisionObject colObj, ContactResultCallback resultCallback)
		{
			btCollisionWorld_contactTest(_native, colObj._native, resultCallback._native);
		}

        static void TestRayCast(CollisionObject testObject)
        {
            Vector3 rayFromWorld = testObject.WorldTransform.Origin + new Vector3(0, 0, -2);
            Vector3 rayToWorld = testObject.WorldTransform.Origin + new Vector3(0, 0, 2);
            var rayCallback = new CustomRayCallback(ref rayFromWorld, ref rayToWorld);
            world.RayTestRef(ref rayFromWorld, ref rayToWorld, rayCallback);
            if (rayCallback.CollisionObject != testObject)
            {
                Console.WriteLine("Raycast FAILED!");
            }

            AddToDisposeQueue(rayCallback);
        }

 void InitRigidBodyInstance(CollisionObject colObj, CollisionShape shape, ref Matrix transform)
 {
     if (shape.ShapeType == BroadphaseNativeType.CompoundShape)
     {
         foreach (var child in (shape as CompoundShape).ChildList)
         {
             Matrix childTransform = child.Transform * transform;
             InitRigidBodyInstance(colObj, child.ChildShape, ref childTransform);
         }
     }
     else
     {
         var shapeData = InitShapeData(shape);
         shapeData.Instances.Add(new InstanceData()
         {
             WorldTransform = transform,
             Color = "Ground".Equals(colObj.UserObject) ? groundColor :
                 colObj.ActivationState == ActivationState.ActiveTag ? activeColor : passiveColor
         });
     }
 }

 public bool NeedsResponse(CollisionObject body0, CollisionObject body1)
 {
     return btDispatcher_needsResponse(_native, body0._native, body1._native);
 }

 public bool CheckCollideWithOverride(CollisionObject co)
 {
     return btCollisionObject_checkCollideWithOverride(_native, co._native);
 }

 void OnContactProcessed(ManifoldPoint cp, CollisionObject body0, CollisionObject body1)
 {
     // Debug.WriteLine("OnContactProcessed");
     cp.UserPersistentData = 1;
 }

		public void UpdateSingleAabb(CollisionObject colObj)
		{
			btCollisionWorld_updateSingleAabb(_native, colObj._native);
		}

		public void RemoveCollisionObject(CollisionObject collisionObject)
		{
            _collisionObjectArray.Remove(collisionObject);
		}

		public static void RayTestSingle(Matrix rayFromTrans, Matrix rayToTrans,
			CollisionObject collisionObject, CollisionShape collisionShape, Matrix colObjWorldTransform,
			RayResultCallback resultCallback)
		{
			btCollisionWorld_rayTestSingle(ref rayFromTrans, ref rayToTrans, collisionObject._native,
				collisionShape._native, ref colObjWorldTransform, resultCallback._native);
		}

		public static void ObjectQuerySingle(ConvexShape castShape, Matrix rayFromTrans,
			Matrix rayToTrans, CollisionObject collisionObject, CollisionShape collisionShape,
			Matrix colObjWorldTransform, ConvexResultCallback resultCallback, float allowedPenetration)
		{
			btCollisionWorld_objectQuerySingle(castShape._native, ref rayFromTrans,
				ref rayToTrans, collisionObject._native, collisionShape._native, ref colObjWorldTransform,
				resultCallback._native, allowedPenetration);
		}

 public PersistentManifold GetNewManifold(CollisionObject b0, CollisionObject b1)
 {
     return new PersistentManifold(btDispatcher_getNewManifold(_native, b0._native, b1._native), true);
 }

        protected virtual void Dispose(bool isdisposing)
        {
            if (isInWorld && isdisposing && m_collisionObject != null)
            {
                BPhysicsWorld pw = BPhysicsWorld.Get();
                if (pw != null && pw.world != null)
                {
                    ((DiscreteDynamicsWorld)pw.world).RemoveCollisionObject(m_collisionObject);
                }
            }
            if (m_collisionObject != null)
            {

                m_collisionObject.Dispose();
                m_collisionObject = null;
            }
        }