bool SphereSphereCollision::resolve() {
    const Vec3 relative_position(bob->position - alice->position);
    const Vec3 contact_normal(relative_position/relative_position.length());
    const Vec3 alice_to_collision(contact_normal * alice->radius);
    const Vec3 bob_to_collision(contact_normal * -bob->radius);
 
    const Vec3 velocity(
        bob->momentum / bob->mass
        + cross(bob->angular_momentum, bob_to_collision) / bob->angular_inertia
        - alice->momentum / alice->mass
        - cross(alice->angular_momentum, alice_to_collision) / alice->angular_inertia);
 
    const Mat3x3 contact_to_world(contact_normal);
 
    const Vec3 contact_velocity(contact_to_world.transposed_transform(velocity));
 
    if (contact_velocity.x >= 0.0f) {
        // XXX: sliding objects should be affected by friction
        return false;
    } else {
        const Mat3x3 bob_impulse_to_torque(Mat3x3::skew_symetric(bob_to_collision));
        const Mat3x3 alice_impulse_to_torque(Mat3x3::skew_symetric(alice_to_collision));
        const Mat3x3 velocity_per_unit_impulse(
            bob_impulse_to_torque
            * Mat3x3::diagonal(1.0f / bob->angular_inertia)
            * bob_impulse_to_torque
            * -1.0f
            + alice_impulse_to_torque
            * Mat3x3::diagonal(1.0f / alice->angular_inertia)
            * alice_impulse_to_torque
            * -1.0f );
 
        const Mat3x3 contact_velocity_per_unit_impulse(
            transpose(contact_to_world)
            * velocity_per_unit_impulse
            * contact_to_world
            // Adding the linear components
            + Mat3x3::diagonal(1.0f / bob->mass)
            + Mat3x3::diagonal(1.0f / alice->mass));
 
        const Mat3x3 contact_impulse_per_unit_velocity(
            inverse(contact_velocity_per_unit_impulse));
 
        // Only rebound when we have a real collision and not a simple contact
        float restitution(0.0f);
        if (-contact_velocity.x > 1.0f) {
            restitution = 0.9f;
        }
        
        const float expected_normal_velocity_change(
            contact_velocity.x * -(1.0f + restitution));
        const Vec3 expected_contact_velocity_change(
            expected_normal_velocity_change,
            - contact_velocity.y,
            - contact_velocity.z);
 
        Vec3 contact_impulse(
            contact_impulse_per_unit_velocity.transform(
                expected_contact_velocity_change));
 
        const float planar_impulse(std::sqrt(
              contact_impulse.y * contact_impulse.y
            + contact_impulse.y * contact_impulse.y));
 
        const float friction(0.1f);
        if (planar_impulse > contact_impulse.x * friction) {
            contact_impulse.y /= planar_impulse;
            contact_impulse.z /= planar_impulse;
 
            contact_impulse.x =
                expected_normal_velocity_change 
                / (
                    contact_velocity_per_unit_impulse.a.x
                    + contact_velocity_per_unit_impulse.a.y * friction * contact_impulse.y
                    + contact_velocity_per_unit_impulse.a.z * friction * contact_impulse.z);
 
            contact_impulse.y *= friction * contact_impulse.x;
            contact_impulse.z *= friction * contact_impulse.x;
        }
 
/* Spinning Friction :
        const Vec3 angular_velocity(
            bob->angular_momentum / bob->angular_inertia
            - alice->angular_momentum / alice->angular_inertia);
        const float normal_angular_velocity(
            dot(angular_velocity, contact_normal));
        const Vec3 tangential_angular_velocity(
            angular_velocity
            - normal_angular_velocity * contact_normal);
*/
 
        const Vec3 impulse(contact_to_world.transform(contact_impulse));
        const Vec3 opposite_impulse(impulse * -1.0f);
 
        // Apply the impulse
        alice->momentum.add(opposite_impulse);
        alice->angular_momentum.add(cross(impulse, alice_to_collision));
        bob->momentum.add(impulse);
        bob->angular_momentum.add(cross(opposite_impulse, bob_to_collision));
 
        return true;
    }
}