internal void UpdateMassProps(HkRigidBody rb)
 {
     var mp = new HkMassProperties();
     mp.InertiaTensor = rb.InertiaTensor;
     mp.Mass = rb.Mass;
     mp.CenterOfMass = rb.CenterOfMassLocal;
     MassElement = new HkMassElement();
     MassElement.Properties = mp;
     MassElement.Tranform = Transform;
     //MassElement.Tranform.Translation = Vector3.Transform(rb.CenterOfMassLocal, Transform);
 }

 void phantom_Enter(HkPhantomCallbackShape sender, HkRigidBody body)
 {
 }

 private static bool IsDynamicGrid(HkRigidBody rb, MyGridPhysics grid)
 {
     return (grid != null && grid.RigidBody == rb && !grid.IsStatic);
 }

 private void phantom_Enter(HkPhantomCallbackShape shape, HkRigidBody body)
 {
     ProfilerShort.Begin("MergeEnter");
     var entities = MyPhysicsExtensions.GetAllEntities(body);
     foreach (var entity in entities)
     {
         var other = entity as MyCubeGrid;
         if (other == null || other.GridSizeEnum != CubeGrid.GridSizeEnum || other == this.CubeGrid)
             continue;
         if(other.Physics.RigidBody != body)
             continue;
         var added = m_gridList.Add(other);
         //Debug.Assert(added, "entity already in list");
     }
     entities.Clear();
     ProfilerShort.End();
 }

 public HkRigidBody SwitchRigidBody(HkRigidBody newBody)
 {
     HkRigidBody old = RigidBody;
     RigidBody = newBody;
     return old;
 }

        protected virtual void CreateBody(ref HkShape shape, HkMassProperties? massProperties)
        {
            ProfilerShort.Begin("CreateBody");
            HkRigidBodyCinfo rbInfo = new HkRigidBodyCinfo();

            rbInfo.AngularDamping = m_angularDamping;
            rbInfo.LinearDamping = m_linearDamping;
            rbInfo.Shape = shape;
            rbInfo.SolverDeactivation = InitialSolverDeactivation;
            rbInfo.ContactPointCallbackDelay = ContactPointDelay;

            if (massProperties.HasValue)
            {
                rbInfo.SetMassProperties(massProperties.Value);
            }

            GetInfoFromFlags(rbInfo, Flags);

            RigidBody = new HkRigidBody(rbInfo);

            ProfilerShort.End();
        }

 private void phantom_Enter(HkPhantomCallbackShape shape, HkRigidBody body)
 {
     if (!Sync.IsServer)
         return;
     var entities = body.GetAllEntities();
     foreach (var entity in entities)
     {
         if (entity is MyFloatingObject)
         {
             m_entitiesToTake.Add(entity as MyFloatingObject);
             NeedsUpdate |= MyEntityUpdateEnum.BEFORE_NEXT_FRAME;
         }
     }
     entities.Clear();
     //if (!Sync.IsServer)
     //    return;
     //var entity = body.GetEntity();
     //if (entity is MyFloatingObject)
     //{
     //    m_inventory.TakeFloatingObject(entity as MyFloatingObject);
     //}
 }

        private DamageImpactEnum GetDamageFromFall(HkRigidBody collidingBody, MyEntity collidingEntity, ref HkContactPointEvent value)
        {
            //if (m_currentMovementState != MyCharacterMovementEnum.Falling || m_currentMovementState != MyCharacterMovementEnum.Jump) return DamageImpactEnum.NoDamage;
            //if (!collidingBody.IsFixed && collidingBody.Mass < Physics.Mass * 50) return DamageImpactEnum.NoDamage;

            float dotProd = Vector3.Dot(value.ContactPoint.Normal, Vector3.Normalize(Physics.HavokWorld.Gravity));

            bool falledOnEntity = dotProd <= 0.0f;

            if (!falledOnEntity) return DamageImpactEnum.NoDamage;

            if (Math.Abs(value.SeparatingVelocity * dotProd) < MyPerGameSettings.CharacterDamageMinVelocity) return DamageImpactEnum.NoDamage;

            if (Math.Abs(value.SeparatingVelocity * dotProd) > MyPerGameSettings.CharacterDamageDeadlyDamageVelocity) return DamageImpactEnum.DeadlyDamage;

            if (Math.Abs(value.SeparatingVelocity * dotProd) > MyPerGameSettings.CharacterDamageMediumDamageVelocity) return DamageImpactEnum.MediumDamage;

            return DamageImpactEnum.SmallDamage;
        }

        private void phantom_EnterConnector(HkPhantomCallbackShape shape, HkRigidBody body)
        {
            ProfilerShort.Begin("ShipConnectorEnterConnector");
            var entities = body.GetAllEntities();
            using (entities.GetClearToken())
            {
                foreach (var entity in entities)
                {
                    var other = entity as MyCubeGrid;
                    if (other == null || other == this.CubeGrid)
                        continue;

                    m_detectedGrids.Add(other);
                }
            }
            ProfilerShort.End();
        }

        private void phantom_EnterEjector(HkPhantomCallbackShape shape, HkRigidBody body)
        {
            ProfilerShort.Begin("ShipConnectorEnterEjector");
            bool updateEmissivity = false;
            var entities = body.GetAllEntities();
            foreach (var entity in entities)
            {
                Debug.Assert(entity is MyFloatingObject);
                if (entity is MyFloatingObject)
                {
                    updateEmissivity |= (m_detectedFloaters.Count == 1);
                    m_detectedFloaters.Add(entity);
                }
            }
            entities.Clear();

            if (updateEmissivity)
                UpdateEmissivity();
            ProfilerShort.End();
        }

 private void phantom_LeaveConnector(HkPhantomCallbackShape shape, HkRigidBody body)
 {
     ProfilerShort.Begin("ShipConnectorLeaveConnector");
     var entities = body.GetAllEntities();
     foreach (var entity in entities)
     {
          m_detectedGrids.Remove(entity as MyCubeGrid);
     }
     entities.Clear();
     ProfilerShort.End();
 }

 private void phantom_LeaveEjector(HkPhantomCallbackShape shape, HkRigidBody body)
 {
     ProfilerShort.Begin("ShipConnectorLeaveEjector");
     var updateEmissivity = (m_detectedFloaters.Count == 2);
     var entities = body.GetAllEntities();
     foreach (var entity in entities)
         m_detectedFloaters.Remove(entity);
     entities.Clear();
     if (updateEmissivity)
         UpdateEmissivity();
     ProfilerShort.End();
 }

        private void Attach(HkRigidBody body, Vector3 gearSpacePivot, Matrix otherBodySpacePivot)
        {
            if (CubeGrid.Physics.Enabled)
            {
                var entity = body.GetEntity();
                Debug.Assert(m_attachedTo == null, "Already attached");
                Debug.Assert(entity != null, "Landing gear is attached to body which has no entity");
                Debug.Assert(m_constraint == null);

                if (m_attachedTo != null || entity == null || m_constraint != null)
                    return;

                body.Activate();
                CubeGrid.Physics.RigidBody.Activate();

                m_attachedTo = entity;

                if (entity != null)
                {
                    entity.OnPhysicsChanged += m_physicsChangedHandler;
                }

                this.OnPhysicsChanged += m_physicsChangedHandler;

                Matrix gearLocalSpacePivot = Matrix.Identity;
                gearLocalSpacePivot.Translation = gearSpacePivot;
                
                var fixedData = new HkFixedConstraintData();
                if (MyFakes.OVERRIDE_LANDING_GEAR_INERTIA)
                {
                    fixedData.SetInertiaStabilizationFactor(MyFakes.LANDING_GEAR_INTERTIA);
                }
                else
                {
                    fixedData.SetInertiaStabilizationFactor(1);
                }

                fixedData.SetSolvingMethod(HkSolvingMethod.MethodStabilized);
                fixedData.SetInBodySpace(ref gearLocalSpacePivot, ref otherBodySpacePivot);

                HkConstraintData data = fixedData;

                if (MyFakes.LANDING_GEAR_BREAKABLE && BreakForce < MaxSolverImpulse)
                {
                    var breakData = new HkBreakableConstraintData(fixedData);
                    fixedData.Dispose();

                    breakData.Threshold = BreakForce;
                    breakData.ReapplyVelocityOnBreak = true;
                    breakData.RemoveFromWorldOnBrake = true;

                    data = breakData;
                }

                if (!m_needsToRetryLock)
                    StartSound(m_lockSound);

                m_constraint = new HkConstraint(CubeGrid.Physics.RigidBody, body, data);
                CubeGrid.Physics.AddConstraint(m_constraint);
                m_constraint.Enabled = true;

                LockMode = LandingGearMode.Locked;
                if (CanAutoLock)
                    ResetAutolock();

                OnConstraintAdded(GridLinkTypeEnum.Physical, entity);
                OnConstraintAdded(GridLinkTypeEnum.NoContactDamage, entity);

                var handle = StateChanged;
                if (handle != null) handle(true);
            }
        }

//.........这里部分代码省略.........
                const short size = 50;
                for (short x = 0; x < size; x++)
                {
                    for (short y = 0; y < size; y++)
                    {
                        for (short z = 0; z < size; z++)
                        {
                            var box = new HkBoxShape(Vector3.One);
                            grid.AddShapes(new System.Collections.Generic.List<HkShape>() { box }, new Vector3S(x, y, z), new Vector3S(x, y, z));
                            trShapes.Add(new HkConvexTranslateShape(box, new Vector3(x, y, z), HkReferencePolicy.None));
                            shapes.Add(box);
                            matrices.Add(Matrix.CreateTranslation(new Vector3(x, y, z)));
                        }
                    }
                }

                var emptyGeom = new HkGeometry(new List<Vector3>(), new List<int>());

                var list = new HkListShape(trShapes.ToArray(), trShapes.Count, HkReferencePolicy.None);
                var compressedBv = new HkBvCompressedMeshShape(emptyGeom, shapes, matrices, HkWeldingType.None);
                var mopp = new HkMoppBvTreeShape(list, HkReferencePolicy.None);

                HkShapeBuffer buf = new HkShapeBuffer();

                //HkShapeContainerIterator i = compressedBv.GetIterator(buf);
                //int count = 0; // will be 125000
                //while (i.IsValid)
                //{
                //    count++;
                //    i.Next();
                //}                

                buf.Dispose();
                var info = new HkRigidBodyCinfo();
                info.Mass = 10;
                info.CalculateBoxInertiaTensor(Vector3.One, 10);
                info.MotionType = HkMotionType.Dynamic;
                info.QualityType = HkCollidableQualityType.Moving;
                info.Shape = compressedBv;
                var body = new HkRigidBody(info);

                //MyPhysics.HavokWorld.AddRigidBody(body);
            }

            if (MyInput.Static.IsNewKeyPressed(MyKeys.NumPad7))
            {
                foreach (var g in MyEntities.GetEntities().OfType<MyCubeGrid>())
                {
                    foreach (var s in g.CubeBlocks.Select(s => s.FatBlock).Where(s => s != null).OfType<MyMotorStator>())
                    {
                        if (s.Rotor != null)
                        {
                            var q = Quaternion.CreateFromAxisAngle(s.Rotor.WorldMatrix.Up, MathHelper.ToRadians(45));
                            s.Rotor.CubeGrid.WorldMatrix = MatrixD.CreateFromQuaternion(q) * s.Rotor.CubeGrid.WorldMatrix;
                        }
                    }
                }
            }

            if (MyInput.Static.IsNewKeyPressed(MyKeys.NumPad8))
            {
                var view = MySession.Static.CameraController.GetViewMatrix();
                var inv = Matrix.Invert(view);

                var oreBuilder = MyObjectBuilderSerializer.CreateNewObject<MyObjectBuilder_Ore>("Stone");
                var obj = new MyObjectBuilder_FloatingObject() { Item = new MyObjectBuilder_InventoryItem() { Content = oreBuilder, Amount = 1000 } };

 void phantom_Leave(HkPhantomCallbackShape sender, HkRigidBody body)
 {
 }

        private DamageImpactEnum GetDamageFromSqueeze(HkRigidBody collidingBody, MyEntity collidingEntity, ref HkContactPointEvent value)
        {
            if (collidingBody.IsFixed || collidingBody.Mass < MyPerGameSettings.CharacterSqueezeMinMass) return DamageImpactEnum.NoDamage;

            if (value.ContactProperties.IsNew) return DamageImpactEnum.NoDamage;

            // the object has to be moving towards the character even slowly and that also the character is not moving away from it
            Vector3 direction = Physics.CharacterProxy.GetHitRigidBody().Position - collidingBody.Position;
            Vector3 gravity = MyGravityProviderSystem.CalculateTotalGravityInPoint(PositionComp.WorldAABB.Center) + Physics.HavokWorld.Gravity;
            direction.Normalize();
            gravity.Normalize();

            float resultToPlayer = Vector3.Dot(direction, gravity);

            if (resultToPlayer < 0.5f) return DamageImpactEnum.NoDamage;

            if (m_squeezeDamageTimer > 0)
            {
                m_squeezeDamageTimer -= VRage.Game.MyEngineConstants.UPDATE_STEP_SIZE_IN_SECONDS;
                return DamageImpactEnum.NoDamage;
            }
            m_squeezeDamageTimer = MyPerGameSettings.CharacterSqueezeDamageDelay;

            if (MyDebugDrawSettings.ENABLE_DEBUG_DRAW && MyDebugDrawSettings.DEBUG_DRAW_SHOW_DAMAGE)
            {
                MatrixD worldMatrix = collidingEntity.Physics.GetWorldMatrix();
                int index = 2;
                MyPhysicsDebugDraw.DrawCollisionShape(collidingBody.GetShape(), worldMatrix, 1, ref index);
                VRageRender.MyRenderProxy.DebugDrawText3D(worldMatrix.Translation, "SQUEEZE, MASS:" + collidingBody.Mass, Color.Yellow, 2, false);
            }

            if (collidingBody.Mass > MyPerGameSettings.CharacterSqueezeDeadlyDamageMass) return DamageImpactEnum.DeadlyDamage;

            if (collidingBody.Mass > MyPerGameSettings.CharacterSqueezeCriticalDamageMass) return DamageImpactEnum.CriticalDamage;

            if (collidingBody.Mass > MyPerGameSettings.CharacterSqueezeMediumDamageMass) return DamageImpactEnum.MediumDamage;

            return DamageImpactEnum.SmallDamage;
        }

        private DamageImpactEnum GetDamageFromHit(HkRigidBody collidingBody, MyEntity collidingEntity, ref HkContactPointEvent value)
        {
            if (collidingBody.LinearVelocity.Length() < MyPerGameSettings.CharacterDamageHitObjectMinVelocity) return DamageImpactEnum.NoDamage;

            if (collidingEntity == ManipulatedEntity) return DamageImpactEnum.NoDamage;

            if (collidingBody.HasProperty(HkCharacterRigidBody.MANIPULATED_OBJECT)) return DamageImpactEnum.NoDamage;

            var mass = (MyPerGameSettings.Destruction ? MyDestructionHelper.MassFromHavok(collidingBody.Mass) : collidingBody.Mass);
            if (mass < MyPerGameSettings.CharacterDamageHitObjectMinMass) return DamageImpactEnum.NoDamage;

            // Get the objects energies to calculate the damage - must be higher above treshold
            float objectEnergy = Math.Abs(value.SeparatingVelocity) * mass;

            if (objectEnergy > MyPerGameSettings.CharacterDamageHitObjectDeadlyEnergy) return DamageImpactEnum.DeadlyDamage;
            if (objectEnergy > MyPerGameSettings.CharacterDamageHitObjectCriticalEnergy) return DamageImpactEnum.CriticalDamage;
            if (objectEnergy > MyPerGameSettings.CharacterDamageHitObjectMediumEnergy) return DamageImpactEnum.MediumDamage;
            if (objectEnergy > MyPerGameSettings.CharacterDamageHitObjectSmallEnergy) return DamageImpactEnum.SmallDamage;

            return DamageImpactEnum.NoDamage;
        }

 private void phantom_LeaveEjector(HkPhantomCallbackShape shape, HkRigidBody body)
 {
     var updateEmissivity = (m_detectedFloaters.Count == 2);
     m_detectedFloaters.Remove(body.GetEntity());
     if (updateEmissivity)
         UpdateEmissivity();
 }

 private void phantom_Leave(HkPhantomCallbackShape shape, HkRigidBody body)
 {
     if (!Sync.IsServer)
         return;
     var entities = body.GetAllEntities();
     foreach(var entity in entities)
         m_entitiesToTake.Remove(entity as MyFloatingObject);
     entities.Clear();
 }

        private void phantom_EnterEjector(HkPhantomCallbackShape shape, HkRigidBody body)
        {
            var entity = body.GetEntity();

            Debug.Assert(entity is MyFloatingObject);
            if (entity is MyFloatingObject)
            {
                var updateEmissivity = (m_detectedFloaters.Count == 1);
                m_detectedFloaters.Add(entity);
                if (updateEmissivity)
                    UpdateEmissivity();
            }
        }