示例#1
0
    //how deep the objects intersect
    private void ResolvePenetration(CollisionHull2D.CollisionInfo colInfo)
    {
        if (colInfo.contacts[0].penetration <= 0.0f)
        {
            return;
        }

        float totalInverseMass = colInfo.RigidBodyA.invMass + colInfo.RigidBodyB.invMass;

        if (totalInverseMass <= 0.0f)
        {
            return;
        }
        Vector2 movePerMass = colInfo.contacts[0].normal * (colInfo.contacts[0].penetration / totalInverseMass);

        colInfo.RigidBodyA.position -= colInfo.RigidBodyA.invMass * movePerMass;
        colInfo.RigidBodyB.position += colInfo.RigidBodyB.invMass * movePerMass;
    }
示例#2
0
    void ResolveVelocity(CollisionHull2D.CollisionInfo collisionInfo)
    {
        float separatingVelocity = Vector2.Dot(collisionInfo.RelativeVelocity, collisionInfo.contacts[0].normal);

        if (separatingVelocity > 0.0f)
        {
            return;
        }
        Vector2     accCausedVelocity  = collisionInfo.RigidBodyA.previousVelocity - collisionInfo.RigidBodyB.previousVelocity;
        const float velLimit           = 1f;
        float       appliedRestitution = collisionInfo.RelativeVelocity.sqrMagnitude < velLimit * velLimit ? 0.0f : collisionInfo.contacts[0].restitution;

        float newSeparatingVelocity = -separatingVelocity * appliedRestitution;



        float accCausedSepVelocity = Vector2.Dot(accCausedVelocity, collisionInfo.contacts[0].normal);

        if (accCausedSepVelocity < 0)
        {
            newSeparatingVelocity += appliedRestitution * accCausedSepVelocity;
            if (newSeparatingVelocity < 0)
            {
                newSeparatingVelocity = 0;
            }
        }

        float deltaVelocity    = newSeparatingVelocity - separatingVelocity;
        float totalInverseMass = collisionInfo.RigidBodyA.GetInverseMass() + collisionInfo.RigidBodyB.GetInverseMass();

        if (totalInverseMass <= 0.0f)
        {
            return;
        }

        float   impulse        = deltaVelocity / totalInverseMass;
        Vector2 impulsePerMass = collisionInfo.contacts[0].normal * impulse;

        collisionInfo.RigidBodyA.velocity -= collisionInfo.RigidBodyA.GetInverseMass() * impulsePerMass;
        collisionInfo.RigidBodyB.velocity += collisionInfo.RigidBodyB.GetInverseMass() * impulsePerMass;
    }
示例#3
0
    void ResolveVelocity(CollisionHull2D.CollisionInfo collisionInfo)
    {
        float separatingVelocity = Vector2.Dot(collisionInfo.RelativeVelocity, collisionInfo.contacts[0].normal);

        if (separatingVelocity > 0.0f)
        {
            return;
        }

        float newSeparatingVelocity = -separatingVelocity * collisionInfo.contacts[0].restitution;

        Vector2 accCausedVelocity = collisionInfo.RigidBodyA.acceleration - collisionInfo.RigidBodyB.acceleration;

        float accCausedSepVelocity = Vector2.Dot(accCausedVelocity, collisionInfo.contacts[0].normal) * Time.fixedDeltaTime;

        if (accCausedSepVelocity < 0)
        {
            newSeparatingVelocity += collisionInfo.contacts[0].restitution * accCausedSepVelocity;
            if (newSeparatingVelocity < 0)
            {
                newSeparatingVelocity = 0;
            }
        }

        float deltaVelocity    = newSeparatingVelocity - separatingVelocity;
        float totalInverseMass = collisionInfo.RigidBodyA.GetInverseMass() + collisionInfo.RigidBodyB.GetInverseMass();

        if (totalInverseMass <= 0.0f)
        {
            return;
        }

        float   impulse        = deltaVelocity / totalInverseMass;
        Vector2 impulsePerMass = collisionInfo.contacts[0].normal * impulse;

        collisionInfo.RigidBodyA.velocity -= collisionInfo.RigidBodyA.GetInverseMass() * impulsePerMass;
        collisionInfo.RigidBodyB.velocity += collisionInfo.RigidBodyB.GetInverseMass() * impulsePerMass;
    }
示例#4
0
    void ResolvePenetration(CollisionHull2D.CollisionInfo collisionInfo)
    {
        if (collisionInfo.contacts[0].penetration <= 0.0f)
        {
            return;
        }

        float totalInverseMass = collisionInfo.RigidBodyA.GetInverseMass() + collisionInfo.RigidBodyB.GetInverseMass();

        if (totalInverseMass <= 0.0f)
        {
            return;
        }

        Vector2 movePerMass = collisionInfo.contacts[0].normal * (collisionInfo.contacts[0].penetration / totalInverseMass);

        if (movePerMass.y > 0.0f)
        {
            Debug.Log(movePerMass.y);
        }
        collisionInfo.RigidBodyA.position -= collisionInfo.RigidBodyA.GetInverseMass() * movePerMass;
        collisionInfo.RigidBodyB.position += collisionInfo.RigidBodyB.GetInverseMass() * movePerMass;
    }