Manifolds between primitives

[kozakromch]

Hello, Thanks for great support. This library is really great.
I don't understand some moments about contact manifolds. And would really appreciate some help.
Right now I need a contact manifold between shapes. For example if I have 2 boxes that collides like that, I hope to have at least one triangle for each box(red lines) Or maybe even more triangles (like blue lines)

But all I get is one contact point if test collision between two boxes. If I test collision between box and kinematic mesh -- everything work great. Am I doing smth wrong ? Or this is the standart behaviour for collision between primitives? Is there way to create manifold between primitives?
Thanks in advance

I take most of the code from physicsSystem.cpp

Test Code

#include <Jolt/Jolt.h>

#include <Jolt/Physics/Collision/CollideShape.h>
#include <Jolt/Physics/Collision/ManifoldBetweenTwoFaces.h>
#include <Jolt/Physics/Collision/Shape/BoxShape.h>
#include <Jolt/Physics/Collision/TransformedShape.h>
#include <iostream>

class MyManifold : public JPH::ContactManifold {
   public:
    JPH::Vec3 mFirstWorldSpaceNormal;
};

class CollideShapeCollectorManifold : public JPH::CollideShapeCollector {
   public:
    CollideShapeCollectorManifold(const JPH::TransformedShape& shape_1,
                                  const JPH::TransformedShape& shape_2,
                                  const JPH::PhysicsSettings& settings)
        : _shape_1(shape_1), _shape_2(shape_2), _settings(settings) {
        std::cout << "CollideShapeCollectorManifold" << std::endl;
    }

    virtual void AddHit(const JPH::CollideShapeResult& inResult) override {
        std::cout << "AddHit" << std::endl;
        // Calculate normal
        JPH::Vec3 world_space_normal = inResult.mPenetrationAxis.Normalized();

        // Check if we can add it to an existing manifold
        float contact_normal_cos_max_delta_rot =
            _settings.mContactNormalCosMaxDeltaRotation;
        MyManifold* manifold = nullptr;
        for (auto& m : _manifolds)
            if (world_space_normal.Dot(m.mFirstWorldSpaceNormal) >=
                contact_normal_cos_max_delta_rot) {
                // Update average normal
                m.mWorldSpaceNormal += world_space_normal;
                m.mPenetrationDepth =
                    JPH::max(m.mPenetrationDepth, inResult.mPenetrationDepth);
                manifold = &m;
                break;
            }
        if (manifold == nullptr) {
            _manifolds.push_back({{_shape_1.mShapePositionCOM,
                                   world_space_normal,
                                   inResult.mPenetrationDepth,
                                   inResult.mSubShapeID1,
                                   inResult.mSubShapeID2,
                                   {},
                                   {}},
                                  world_space_normal});
            manifold = &_manifolds.back();
        }
        // Determine contact points
        JPH::ManifoldBetweenTwoFaces(inResult.mContactPointOn1,
                                     inResult.mContactPointOn2,
                                     inResult.mPenetrationAxis,
                                     _settings.mSpeculativeContactDistance +
                                         _settings.mManifoldToleranceSq,
                                     inResult.mShape1Face, inResult.mShape2Face,
                                     manifold->mRelativeContactPointsOn1,
                                     manifold->mRelativeContactPointsOn2);
    }
    const JPH::TransformedShape& _shape_1;
    const JPH::TransformedShape& _shape_2;
    const JPH::PhysicsSettings _settings;
    std::vector<MyManifold> _manifolds;
};

void testManifolds() {
    JPH::BoxShapeSettings box_shape_settings_1(JPH::Vec3(10.0f, 10.0f, 10.0f));
    JPH::BoxShapeSettings box_shape_settings_2(JPH::Vec3(10.0f, 10.0f, 10.0f));
    const auto& box_shape_result_1 = box_shape_settings_1.Create();
    if (box_shape_result_1.HasError())
        throw common::CscException(box_shape_result_1.GetError());
    const auto& box_shape_result_2 = box_shape_settings_2.Create();
    if (box_shape_result_2.HasError())
        throw common::CscException(box_shape_result_2.GetError());
    JPH::Ref<JPH::Shape> box_shape_1 = box_shape_result_1.Get();
    JPH::Ref<JPH::Shape> box_shape_2 = box_shape_result_2.Get();

    const JPH::Vec3 translation(9.0f, 0.0f, 0.0f);
    JPH::TransformedShape box_transformed_shape_1(
        translation, JPH::Quat::sIdentity(), box_shape_1, JPH::BodyID(1));
    JPH::TransformedShape box_transformed_shape_2(
        translation, JPH::Quat::sIdentity(), box_shape_2, JPH::BodyID(2));
    // create collide settings
    JPH::CollideShapeSettings collide_settings;
    CollideShapeCollectorManifold collector(box_transformed_shape_1,
                                            box_transformed_shape_2,
                                            JPH::PhysicsSettings());
    box_transformed_shape_1.CollideShape(
        box_shape_2, JPH::Vec3::sReplicate(1.0f), JPH::Mat44::sIdentity(),
        collide_settings, JPH::Vec3::sZero(), collector);

    // print all manifold from collector
    std::cout << "Manifolds: " << std::endl;
    for (auto& manifold : collector._manifolds) {
        std::cout << "Penetration depth: " << manifold.mPenetrationDepth
                  << std::endl;
        // print all contact points for 1 body

        for (auto& contact_point : manifold.mRelativeContactPointsOn1) {
            std::cout << "Contact point1: " << contact_point << std::endl;
        }
        for (auto& contact_point : manifold.mRelativeContactPointsOn2) {
            std::cout << "Contact point2: " << contact_point << std::endl;
        }
    }
}

This code give me

Manifolds:
Penetration depth: 11
Contact point1: 10, 5, 0
Contact point2: -1, 5, 0

So only one contact point and only one manifold.

[jrouwe]

I think you need to add:

collide_settings.mCollectFacesMode = ECollectFacesMode::CollectFaces

in order to actually populate mContactPointOn1 and mContactPointOn2.

This also looks incorrect (adding a squared distance and a non-squared distance):

_settings.mSpeculativeContactDistance + _settings.mManifoldToleranceSq,

Note that in the master version of Jolt the ManifoldBetweenTwoFaces has a bug fix and takes a non-squared value.