Distance between shapes

[kozakromch]

Hello, thanks again for such a wonderful library. It's really cool and stable.
I'm wondering if there is a way to get the minimum distance between the shapes?
I am especially interested in a task like this:
I have one object and I need to find another object with the minimum distance. I found out that the api allows to make a ray cast, but it is not always close to the real distance. And as far as I know, GJK allows to calculate the distance between objects, so I'm not sure if there really isn't such a possibility or if I haven't found it.
Thank's in advance

[jrouwe]

You can use the CollideShape function (either on Shape or NarrowPhaseQuery) and pass in a CollideShapeSettings object with mMaxSeparationDistance > 0. You'll then receive hit results with a negative penetration depth, indicating how far away the closest point is.

[kozakromch]

Thank you, for great answer.
I try the solution you gave and saw smth strange.

struct CollideShapeCollectorImpl : public JPH::CollideShapeCollector {
    CollideShapeCollectorImpl() : JPH::CollideShapeCollector() {}
    void AddHit(const JPH::CollideShapeResult& inResult) override {
        result = inResult;
        hit = true;
    }
    bool hit = false;
    JPH::CollideShapeResult result;
};

static void test() {
    JPH::SphereShapeSettings sphere_shape_settings(1.0f);
    JPH::BoxShapeSettings box_shape_settings(JPH::Vec3(10.0f, 10.0f, 10.0f),
                                             0.1f);
    const auto& sphere_shape_result = sphere_shape_settings.Create();
    const auto& box_shape_result = box_shape_settings.Create();
    if (sphere_shape_result.HasError())
        throw common::CscException(sphere_shape_result.GetError());
    if (box_shape_result.HasError())
        throw common::CscException(box_shape_result.GetError());
    JPH::Ref<JPH::Shape> sphere_shape = sphere_shape_result.Get();
    JPH::Ref<JPH::Shape> box_shape = box_shape_result.Get();
    // create transformed shapes
    JPH::TransformedShape sphere_transformed_shape(
        JPH::Vec3::sZero(), JPH::Quat::sIdentity(), sphere_shape,
        JPH::BodyID(0));
    JPH::TransformedShape box_transformed_shape(
        JPH::Vec3::sZero(), JPH::Quat::sIdentity(), box_shape, JPH::BodyID(1));
    // create collide settings
    JPH::CollideShapeSettings collide_settings;
    collide_settings.mMaxSeparationDistance = 0.0f;

    CollideShapeCollectorImpl collector1;

    sphere_transformed_shape.CollideShape(
        box_shape, JPH::Vec3::sReplicate(1.0f), JPH::Mat44::sIdentity(),
        collide_settings, JPH::Vec3::sZero(), collector1);
    
    if (collector1.hit) {
        std::cout << "zero distance penetration depth: "
                  << collector1.result.mPenetrationDepth << std::endl;
    }

    collide_settings.mMaxSeparationDistance = 1000.0f;
    CollideShapeCollectorImpl collector2;
    sphere_transformed_shape.CollideShape(
        box_shape, JPH::Vec3::sReplicate(1.0f), JPH::Mat44::sIdentity(),
        collide_settings, JPH::Vec3::sZero(), collector2);

    if (collector2.hit) {
        std::cout << "big distance penetration depth: "
                  << collector2.result.mPenetrationDepth << std::endl;
    }
}

Here I create two collide test. First with mMaxSeparation Distance = 0 and second with 1000. Adn somehow I get this result

zero distance penetration depth: 10.9997
big distance penetration depth: -18.676

Am I doing smth wrong? or this is the right behaviour and I need at the begining check with zero distance to get all collisions and after that with distance > 0 to get distance between shapes?

[jrouwe]

At a first glance, this appears to be a bug. I'll need some time to look into this.

[jrouwe]

It's a floating point precision issue, if I change your code to:

	struct CollideShapeCollectorImpl : public JPH::CollideShapeCollector {
	CollideShapeCollectorImpl() : JPH::CollideShapeCollector() {}
	void AddHit(const JPH::CollideShapeResult& inResult) override {
		result = inResult;
		hit = true;
	}
	bool hit = false;
	JPH::CollideShapeResult result;
	};

	JPH::SphereShapeSettings sphere_shape_settings(1.0f);
	JPH::BoxShapeSettings box_shape_settings(JPH::Vec3(10.0f, 10.0f, 10.0f), 0.1f);
	const auto& sphere_shape_result = sphere_shape_settings.Create();
	const auto& box_shape_result = box_shape_settings.Create();
	JPH_ASSERT(!sphere_shape_result.HasError());
	JPH_ASSERT(!box_shape_result.HasError());
	JPH::Ref<JPH::Shape> sphere_shape = sphere_shape_result.Get();
	JPH::Ref<JPH::Shape> box_shape = box_shape_result.Get();
	JPH::TransformedShape sphere_transformed_shape(
		JPH::RVec3::sZero(), JPH::Quat::sIdentity(), sphere_shape,
		JPH::BodyID(0));
	
	for (float f : { 0.0f, 1.0f, 10.0f, 100.0f, 250.0f, 500.0f, 750.0f, 1000.0f })
	{
		JPH::CollideShapeSettings collide_settings;
		collide_settings.mMaxSeparationDistance = f;
		CollideShapeCollectorImpl collector;
		sphere_transformed_shape.CollideShape(
			box_shape, JPH::Vec3::sReplicate(1.0f), JPH::RMat44::sIdentity(),
			collide_settings, JPH::RVec3::sZero(), collector);

		if (collector.hit) {
			Trace("max sep = %f -> pen depth = %f", collide_settings.mMaxSeparationDistance, collector.result.mPenetrationDepth);
		}
	}

Then it outputs:

max sep = 0.000000 -> pen depth = 10.999685
max sep = 1.000000 -> pen depth = 11.000000
max sep = 10.000000 -> pen depth = 10.999474
max sep = 100.000000 -> pen depth = 10.880264
max sep = 250.000000 -> pen depth = 6.887268
max sep = 500.000000 -> pen depth = -2.194458
max sep = 750.000000 -> pen depth = -10.771545
max sep = 1000.000000 -> pen depth = -18.675964

So you can see it's reasonably accurate until a max separation distance of about 100. After that it starts becoming inaccurate. The reason is that effectively what you're asking the system to do is to take a sphere of radius 1, add 1000 to it and then to check what shortest way out for the box is:

Because the box is exactly in the middle, there are multiple directions that have the same penetration depth and the EPA algorithm that I'm using will start to tesselate a shape that looks like a box expanded by a sphere. Since you can't properly represent a round shape with flat polygons, this naturally leads to some error and if after the algorithm finishes you subtract 1000 from the penetration depth to get the 'real' penetration you end up with a big error.

[jrouwe]

I came up with a fix: #1451