Example #1
0
        internal void SetRigidBodyTransform(MatrixD worldMatrix)
        {
            Matrix rigidBodyMatrix = GetRigidBodyMatrix(worldMatrix);

            if (RigidBody != null)
            {
                RigidBody.SetWorldMatrix(rigidBodyMatrix);
            }

            Matrix m  = RigidBody.GetRigidBodyMatrix();
            Matrix wM = GetWorldMatrix();

            if (RigidBody2 != null)
            {
                RigidBody2.SetWorldMatrix(rigidBodyMatrix);
            }

            if (CharacterProxy != null)
            {
                CharacterProxy.Position = rigidBodyMatrix.Translation;
                CharacterProxy.Forward  = rigidBodyMatrix.Forward;
                CharacterProxy.Up       = rigidBodyMatrix.Up;
                CharacterProxy.Speed    = 0;

                if (CharacterProxy.ImmediateSetWorldTransform)
                {
                    CharacterProxy.SetRigidBodyTransform(rigidBodyMatrix);
                }
            }
        }
Example #2
0
        public override void ActivateBatch(object world, ulong clusterObjectID)
        {
            System.Diagnostics.Debug.Assert(m_world == null, "Cannot activate already active object!");

            m_world         = (HkWorld)world;
            ClusterObjectID = clusterObjectID;
            IsInWorld       = true;

            Matrix rigidBodyMatrix = GetRigidBodyTransform();

            if (RigidBody != null)
            {
                RigidBody.SetWorldMatrix(rigidBodyMatrix);
                m_world.AddRigidBodyBatch(RigidBody);
            }
            if (RigidBody2 != null)
            {
                RigidBody2.SetWorldMatrix(rigidBodyMatrix);
                m_world.AddRigidBodyBatch(RigidBody2);
            }

            if (CharacterProxy != null)
            {
                CharacterProxy.SetRigidBodyTransform(rigidBodyMatrix);
                CharacterProxy.Activate(m_world);
            }

            foreach (var constraint in m_constraints)
            {
                m_constraintsAddBatch.Add(constraint);
            }
        }
        public void SwitchToRagdollMode(bool deadMode = true, int firstRagdollSubID = 1)
        {
            Debug.Assert(Enabled, "Trying to switch to ragdoll mode, but Physics are not enabled");

            if (MyFakes.ENABLE_RAGDOLL_DEBUG)
            {
                Debug.WriteLine("MyPhysicsBody.SwitchToRagdollMode");
                MyLog.Default.WriteLine("MyPhysicsBody.SwitchToRagdollMode");
            }

            if (HavokWorld == null || !Enabled)
            {
                SwitchToRagdollModeOnActivate = true;
                m_ragdollDeadMode             = deadMode;
                return;
            }

            if (IsRagdollModeActive)
            {
                Debug.Fail("Ragdoll mode is already active!");
                return;
            }

            Matrix havokMatrix = Entity.WorldMatrix;

            havokMatrix.Translation = WorldToCluster(havokMatrix.Translation);
            Debug.Assert(havokMatrix.IsValid() && havokMatrix != Matrix.Zero, "Invalid world matrix!");

            if (RagdollSystemGroupCollisionFilterID == 0)
            {
                RagdollSystemGroupCollisionFilterID = m_world.GetCollisionFilter().GetNewSystemGroup();
            }

            Ragdoll.SetToKeyframed();   // this will disable the bodies to get the impulse when repositioned

            Ragdoll.GenerateRigidBodiesCollisionFilters(deadMode ? MyPhysics.CollisionLayers.CharacterCollisionLayer : MyPhysics.CollisionLayers.RagdollCollisionLayer, RagdollSystemGroupCollisionFilterID, firstRagdollSubID);

            Ragdoll.ResetToRigPose();

            Ragdoll.SetWorldMatrix(havokMatrix);

            if (deadMode)
            {
                Ragdoll.SetToDynamic();
            }

            if (deadMode)
            {
                foreach (HkRigidBody body in Ragdoll.RigidBodies)
                {
                    // set the velocities for the bodies
                    body.AngularVelocity = AngularVelocity;
                    body.LinearVelocity  = LinearVelocity;
                }
            }
            else
            {
                Ragdoll.ResetVelocities();
            }

            if (CharacterProxy != null && deadMode)
            {
                CharacterProxy.Deactivate(HavokWorld);
                CharacterProxy.Dispose();
                CharacterProxy = null;
            }

            if (RigidBody != null && deadMode)
            {
                RigidBody.Deactivate();
                HavokWorld.RemoveRigidBody(RigidBody);
                RigidBody.Dispose();
                RigidBody = null;
            }

            if (RigidBody2 != null && deadMode)
            {
                RigidBody2.Deactivate();
                HavokWorld.RemoveRigidBody(RigidBody2);
                RigidBody2.Dispose();
                RigidBody2 = null;
            }

            foreach (var body in Ragdoll.RigidBodies)
            {
                body.UserObject = deadMode ? this : null;

                // TODO: THIS SHOULD BE SET IN THE RAGDOLL MODEL AND NOT DEFINING IT FOR EVERY MODEL HERE
                body.Motion.SetDeactivationClass(deadMode ? HkSolverDeactivation.High : HkSolverDeactivation.Medium);// - TODO: Find another way - this is deprecated by Havok
            }

            Ragdoll.OptimizeInertiasOfConstraintTree();

            if (!Ragdoll.InWorld)
            {
                //Ragdoll.RecreateConstraints();
                HavokWorld.AddRagdoll(Ragdoll);
            }

            Ragdoll.EnableConstraints();
            Ragdoll.Activate();
            m_ragdollDeadMode = deadMode;

            if (MyFakes.ENABLE_RAGDOLL_DEBUG)
            {
                Debug.WriteLine("MyPhysicsBody.SwitchToRagdollMode - FINISHED");
                MyLog.Default.WriteLine("MyPhysicsBody.SwitchToRagdollMode - FINISHED");
            }
        }
    public override void Execute(INotification notification)
    {
        CharacterProxy proxy = (CharacterProxy)Facade.RetrieveProxy(CharacterProxy.NAME);

        proxy.ChangeLevel(1);
    }